1//
2// include/gen/algo_gen.inl.h
3// Generated by AMC
4//
5// Copyright (C) 2008-2013 AlgoEngineering LLC
6// Copyright (C) 2013-2019 NYSE | Intercontinental Exchange
7// Copyright (C) 2020-2023 Astra
8// Copyright (C) 2023 AlgoRND
9//
10// This program is free software: you can redistribute it and/or modify
11// it under the terms of the GNU General Public License as published by
12// the Free Software Foundation, either version 3 of the License, or
13// (at your option) any later version.
14//
15// This program is distributed in the hope that it will be useful,
16// but WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18// GNU General Public License for more details.
19//
20// You should have received a copy of the GNU General Public License
21// along with this program. If not, see <https://www.gnu.org/licenses/>.
22//
23
24
25#pragma once
26//#pragma endinclude
27inline cstring& cstring::operator =(const cstring &rhs) {
28 algo::ch_Setary(*this, (algo::cstring&)rhs);
29 return *this;
30}
31
32inline cstring::cstring(const algo::strptr &rhs) {
33 algo::cstring_Init(*this);
34 algo::ch_Addary(*this, aryptr<char>((char*)rhs.elems, rhs.n_elems));
35}
36
37inline cstring::cstring(const tempstr &rhs) {
38 ch_elems = rhs.ch_elems;
39 ch_n = rhs.ch_n;
40 ch_max = rhs.ch_max;
41 cstring &r = (cstring&) rhs;
42 r.ch_elems = 0;
43 r.ch_n = 0;
44 r.ch_max = 0;
45}
46
47
48inline bool algo::cstring::operator ==(const algo::cstring &rhs) const {
49 return algo::cstring_Eq(const_cast<algo::cstring&>(*this),const_cast<algo::cstring&>(rhs));
50}
51
52inline bool algo::cstring::operator !=(const algo::cstring &rhs) const {
53 return !algo::cstring_Eq(const_cast<algo::cstring&>(*this),const_cast<algo::cstring&>(rhs));
54}
55
56inline bool algo::cstring::operator <(const algo::cstring &rhs) const {
57 return algo::cstring_Lt(const_cast<algo::cstring&>(*this),const_cast<algo::cstring&>(rhs));
58}
59
60inline bool algo::cstring::operator >(const algo::cstring &rhs) const {
61 return rhs < *this;
62}
63
64inline bool algo::cstring::operator <=(const algo::cstring &rhs) const {
65 return !(rhs < *this);
66}
67
68inline bool algo::cstring::operator >=(const algo::cstring &rhs) const {
69 return !(*this < rhs);
70}
71inline algo::cstring::cstring() {
72 algo::cstring_Init(*this);
73}
74
75inline algo::cstring::~cstring() {
76 algo::cstring_Uninit(*this);
77}
78
79
80// --- algo.cstring.ch.EmptyQ
81// Return true if index is empty
82inline bool algo::ch_EmptyQ(algo::cstring& parent) {
83 return parent.ch_n == 0;
84}
85
86// --- algo.cstring.ch.Find
87// Look up row by row id. Return NULL if out of range
88inline char* algo::ch_Find(algo::cstring& parent, u64 t) {
89 u64 idx = t;
90 u64 lim = parent.ch_n;
91 if (idx >= lim) return NULL;
92 return parent.ch_elems + idx;
93}
94
95// --- algo.cstring.ch.Getary
96// Return array pointer by value
97inline algo::aryptr<char> algo::ch_Getary(const algo::cstring& parent) {
98 return algo::aryptr<char>(parent.ch_elems, parent.ch_n);
99}
100
101// --- algo.cstring.ch.Last
102// Return pointer to last element of array, or NULL if array is empty
103inline char* algo::ch_Last(algo::cstring& parent) {
104 return ch_Find(parent, u64(parent.ch_n-1));
105}
106
107// --- algo.cstring.ch.Max
108// Return max. number of items in the array
109inline i32 algo::ch_Max(algo::cstring& parent) {
110 (void)parent;
111 return parent.ch_max;
112}
113
114// --- algo.cstring.ch.N
115// Return number of items in the array
116inline i32 algo::ch_N(const algo::cstring& parent) {
117 return parent.ch_n;
118}
119
120// --- algo.cstring.ch.RemoveAll
121inline void algo::ch_RemoveAll(algo::cstring& parent) {
122 parent.ch_n = 0;
123}
124
125// --- algo.cstring.ch.Reserve
126// Make sure N *more* elements will fit in array. Process dies if out of memory
127inline void algo::ch_Reserve(algo::cstring& parent, int n) {
128 u32 new_n = parent.ch_n + n;
129 if (UNLIKELY(new_n > parent.ch_max)) {
130 ch_AbsReserve(parent, new_n);
131 }
132}
133
134// --- algo.cstring.ch.qFind
135// 'quick' Access row by row id. No bounds checking.
136inline char& algo::ch_qFind(algo::cstring& parent, u64 t) {
137 return parent.ch_elems[t];
138}
139
140// --- algo.cstring.ch.qLast
141// Return reference to last element of array. No bounds checking
142inline char& algo::ch_qLast(algo::cstring& parent) {
143 return ch_qFind(parent, u64(parent.ch_n-1));
144}
145
146// --- algo.cstring.ch.rowid_Get
147// Return row id of specified element
148inline u64 algo::ch_rowid_Get(algo::cstring& parent, char &elem) {
149 u64 id = &elem - parent.ch_elems;
150 return u64(id);
151}
152
153// --- algo.cstring.ch.Cast
154inline algo::cstring::operator algo::strptr () const {
155 return ch_Getary(*this);
156}
157
158// --- algo.cstring.ch_curs.Next
159// proceed to next item
160inline void algo::cstring_ch_curs_Next(cstring_ch_curs &curs) {
161 curs.index++;
162}
163
164// --- algo.cstring.ch_curs.Reset
165inline void algo::cstring_ch_curs_Reset(cstring_ch_curs &curs, algo::cstring &parent) {
166 curs.elems = parent.ch_elems;
167 curs.n_elems = parent.ch_n;
168 curs.index = 0;
169}
170
171// --- algo.cstring.ch_curs.ValidQ
172// cursor points to valid item
173inline bool algo::cstring_ch_curs_ValidQ(cstring_ch_curs &curs) {
174 return curs.index < curs.n_elems;
175}
176
177// --- algo.cstring.ch_curs.Access
178// item access
179inline char& algo::cstring_ch_curs_Access(cstring_ch_curs &curs) {
180 return curs.elems[curs.index];
181}
182
183// --- algo.cstring..Lt
184inline bool algo::cstring_Lt(algo::cstring& lhs, algo::cstring& rhs) {
185 return ch_Cmp(lhs,rhs) < 0;
186}
187
188// --- algo.cstring..Cmp
189inline i32 algo::cstring_Cmp(algo::cstring& lhs, algo::cstring& rhs) {
190 i32 retval = 0;
191 retval = ch_Cmp(lhs,rhs);
192 return retval;
193}
194
195// --- algo.cstring..Init
196// Set all fields to initial values.
197inline void algo::cstring_Init(algo::cstring& parent) {
198 parent.ch_elems = 0; // (algo.cstring.ch)
199 parent.ch_n = 0; // (algo.cstring.ch)
200 parent.ch_max = 0; // (algo.cstring.ch)
201}
202
203// --- algo.cstring..Eq
204inline bool algo::cstring_Eq(algo::cstring& lhs, algo::cstring& rhs) {
205 bool retval = true;
206 retval = ch_Eq(lhs,rhs);
207 return retval;
208}
209
210// --- algo.cstring..Update
211// Set value. Return true if new value is different from old value.
212inline bool algo::cstring_Update(algo::cstring &lhs, algo::cstring& rhs) {
213 bool ret = !cstring_Eq(lhs, rhs); // compare values
214 if (ret) {
215 lhs = rhs; // update
216 }
217 return ret;
218}
219inline algo::Attr::Attr(const algo::strptr& in_name
220 ,const algo::strptr& in_value)
221 : name(in_name)
222 , value(in_value)
223{
224}
225
226inline bool algo::Attr::operator ==(const algo::Attr &rhs) const {
227 return algo::Attr_Eq(const_cast<algo::Attr&>(*this),const_cast<algo::Attr&>(rhs));
228}
229
230inline bool algo::Attr::operator !=(const algo::Attr &rhs) const {
231 return !algo::Attr_Eq(const_cast<algo::Attr&>(*this),const_cast<algo::Attr&>(rhs));
232}
233inline algo::Attr::Attr() {
234}
235
236
237// --- algo.Attr..Cmp
238inline i32 algo::Attr_Cmp(algo::Attr& lhs, algo::Attr& rhs) {
239 i32 retval = 0;
240 retval = algo::cstring_Cmp(lhs.name, rhs.name);
241 if (retval != 0) {
242 return retval;
243 }
244 retval = algo::cstring_Cmp(lhs.value, rhs.value);
245 return retval;
246}
247
248// --- algo.Attr..Eq
249inline bool algo::Attr_Eq(algo::Attr& lhs, algo::Attr& rhs) {
250 bool retval = true;
251 retval = algo::cstring_Eq(lhs.name, rhs.name);
252 if (!retval) {
253 return false;
254 }
255 retval = algo::cstring_Eq(lhs.value, rhs.value);
256 return retval;
257}
258inline algo::Bool::Bool(u8 in_value)
259 : value(in_value)
260{
261}
262inline algo::Bool::Bool(algo_BoolEnum arg) { this->value = u8(arg); }
263inline algo::Bool::Bool() {
264 algo::Bool_Init(*this);
265}
266
267
268// --- algo.Bool.value.GetEnum
269// Get value of field as enum type
270inline algo_BoolEnum algo::value_GetEnum(const algo::Bool& parent) {
271 return algo_BoolEnum(parent.value);
272}
273
274// --- algo.Bool.value.SetEnum
275// Set value of field from enum type.
276inline void algo::value_SetEnum(algo::Bool& parent, algo_BoolEnum rhs) {
277 parent.value = u8(rhs);
278}
279
280// --- algo.Bool.value.Cast
281inline algo::Bool::operator algo_BoolEnum () const {
282 return algo_BoolEnum((*this).value);
283}
284
285// --- algo.Bool..Init
286// Set all fields to initial values.
287inline void algo::Bool_Init(algo::Bool& parent) {
288 parent.value = u8(false);
289}
290inline algo::ByteAry::ByteAry() {
291 algo::ByteAry_Init(*this);
292}
293
294inline algo::ByteAry::~ByteAry() {
295 algo::ByteAry_Uninit(*this);
296}
297
298
299// --- algo.ByteAry.ary.EmptyQ
300// Return true if index is empty
301inline bool algo::ary_EmptyQ(algo::ByteAry& parent) {
302 return parent.ary_n == 0;
303}
304
305// --- algo.ByteAry.ary.Find
306// Look up row by row id. Return NULL if out of range
307inline u8* algo::ary_Find(algo::ByteAry& parent, u64 t) {
308 u64 idx = t;
309 u64 lim = parent.ary_n;
310 if (idx >= lim) return NULL;
311 return parent.ary_elems + idx;
312}
313
314// --- algo.ByteAry.ary.Getary
315// Return array pointer by value
316inline algo::aryptr<u8> algo::ary_Getary(const algo::ByteAry& parent) {
317 return algo::aryptr<u8>(parent.ary_elems, parent.ary_n);
318}
319
320// --- algo.ByteAry.ary.Last
321// Return pointer to last element of array, or NULL if array is empty
322inline u8* algo::ary_Last(algo::ByteAry& parent) {
323 return ary_Find(parent, u64(parent.ary_n-1));
324}
325
326// --- algo.ByteAry.ary.Max
327// Return max. number of items in the array
328inline i32 algo::ary_Max(algo::ByteAry& parent) {
329 (void)parent;
330 return parent.ary_max;
331}
332
333// --- algo.ByteAry.ary.N
334// Return number of items in the array
335inline i32 algo::ary_N(const algo::ByteAry& parent) {
336 return parent.ary_n;
337}
338
339// --- algo.ByteAry.ary.RemoveAll
340inline void algo::ary_RemoveAll(algo::ByteAry& parent) {
341 parent.ary_n = 0;
342}
343
344// --- algo.ByteAry.ary.Reserve
345// Make sure N *more* elements will fit in array. Process dies if out of memory
346inline void algo::ary_Reserve(algo::ByteAry& parent, int n) {
347 u32 new_n = parent.ary_n + n;
348 if (UNLIKELY(new_n > parent.ary_max)) {
349 ary_AbsReserve(parent, new_n);
350 }
351}
352
353// --- algo.ByteAry.ary.qFind
354// 'quick' Access row by row id. No bounds checking.
355inline u8& algo::ary_qFind(algo::ByteAry& parent, u64 t) {
356 return parent.ary_elems[t];
357}
358
359// --- algo.ByteAry.ary.qLast
360// Return reference to last element of array. No bounds checking
361inline u8& algo::ary_qLast(algo::ByteAry& parent) {
362 return ary_qFind(parent, u64(parent.ary_n-1));
363}
364
365// --- algo.ByteAry.ary.rowid_Get
366// Return row id of specified element
367inline u64 algo::ary_rowid_Get(algo::ByteAry& parent, u8 &elem) {
368 u64 id = &elem - parent.ary_elems;
369 return u64(id);
370}
371
372// --- algo.ByteAry.ary.Cast
373inline algo::ByteAry::operator algo::memptr () const {
374 return ary_Getary(*this);
375}
376
377// --- algo.ByteAry.ary_curs.Next
378// proceed to next item
379inline void algo::ByteAry_ary_curs_Next(ByteAry_ary_curs &curs) {
380 curs.index++;
381}
382
383// --- algo.ByteAry.ary_curs.Reset
384inline void algo::ByteAry_ary_curs_Reset(ByteAry_ary_curs &curs, algo::ByteAry &parent) {
385 curs.elems = parent.ary_elems;
386 curs.n_elems = parent.ary_n;
387 curs.index = 0;
388}
389
390// --- algo.ByteAry.ary_curs.ValidQ
391// cursor points to valid item
392inline bool algo::ByteAry_ary_curs_ValidQ(ByteAry_ary_curs &curs) {
393 return curs.index < curs.n_elems;
394}
395
396// --- algo.ByteAry.ary_curs.Access
397// item access
398inline u8& algo::ByteAry_ary_curs_Access(ByteAry_ary_curs &curs) {
399 return curs.elems[curs.index];
400}
401
402// --- algo.ByteAry..Init
403// Set all fields to initial values.
404inline void algo::ByteAry_Init(algo::ByteAry& parent) {
405 parent.ary_elems = 0; // (algo.ByteAry.ary)
406 parent.ary_n = 0; // (algo.ByteAry.ary)
407 parent.ary_max = 0; // (algo.ByteAry.ary)
408}
409inline algo::Charset::Charset() {
410 algo::Charset_Init(*this);
411}
412
413
414// --- algo.Charset.ch.NBits
415// Get max # of bits in the bitset
416// Return max. number of bits supported by array
417inline int algo::ch_Nbits(algo::Charset& parent) {
418 return ch_N(parent) * 64;
419}
420
421// --- algo.Charset.ch.qGetBit
422// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
423inline bool algo::ch_qGetBit(algo::Charset& parent, u32 bit_idx) {
424 u64 elem_idx = bit_idx >> 6;
425 u64 shift = bit_idx & 63;
426 u64 &elem = ch_qFind(parent, elem_idx); // fetch element
427 return bool((elem >> shift) & 1); // extract bit
428}
429
430// --- algo.Charset.ch.GetBit
431// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
432inline bool algo::ch_GetBit(algo::Charset& parent, u32 bit_idx) {
433 u64 elem_idx = bit_idx >> 6;
434 u64 shift = bit_idx & 63;
435 bool ret = false;
436 u64 lim = ch_N(parent);
437 if (elem_idx < lim) {
438 u64 &elem = ch_qFind(parent, elem_idx); // fetch element
439 ret = (elem >> shift) & 1; // extract bit
440 }
441 return ret;
442}
443
444// --- algo.Charset.ch.BitsEmptyQ
445// Check if all the bits in the bitset are equal to zero
446inline bool algo::ch_BitsEmptyQ(algo::Charset& parent) {
447 bool retval = true;
448 u64 n = ch_N(parent);
449 for (u64 i = 0; i < n; i++) {
450 if (ch_qFind(parent,i) != 0) {
451 retval = false;
452 break;
453 }
454 }
455 return retval;
456}
457
458// --- algo.Charset.ch.Sum1s
459inline u64 algo::ch_Sum1s(algo::Charset& parent) {
460 u64 sum = 0;
461 u64 n = ch_N(parent);
462 for (u64 i = 0; i < n; i++) {
463 sum += algo::u64_Count1s(ch_qFind(parent, i));
464 }
465 return sum;
466}
467
468// --- algo.Charset.ch.qClearBit
469// Clear bit # BIT_IDX in bit set. No bounds checking
470inline void algo::ch_qClearBit(algo::Charset& parent, u32 bit_idx) {
471 u64 elem_idx = bit_idx >> 6;
472 u64 shift = bit_idx & 63;
473 u64 &elem = ch_qFind(parent, elem_idx); // fetch
474 elem = elem & ~(u64(1) << shift); // clear bit
475}
476
477// --- algo.Charset.ch.ClearBit
478// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
479inline void algo::ch_ClearBit(algo::Charset& parent, u32 bit_idx) {
480 u64 elem_idx = bit_idx >> 6;
481 u64 shift = bit_idx & 63;
482 u64 lim = ch_N(parent);
483 if (elem_idx < lim) {
484 u64 &elem = ch_qFind(parent, elem_idx); // fetch
485 elem = elem & ~(u64(1) << shift); // clear bit
486 }
487}
488
489// --- algo.Charset.ch.qSetBit
490// Set bit # BIT_IDX in bit set. No bounds checking
491inline void algo::ch_qSetBit(algo::Charset& parent, u32 bit_idx) {
492 u64 elem_idx = bit_idx >> 6;
493 u64 shift = bit_idx & 63;
494 u64 &elem = ch_qFind(parent, elem_idx); // fetch
495 elem = elem | (u64(1) << shift); // set bit
496}
497
498// --- algo.Charset.ch.SetBit
499// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
500inline void algo::ch_SetBit(algo::Charset& parent, u32 bit_idx) {
501 u64 elem_idx = bit_idx >> 6;
502 u64 shift = bit_idx & 63;
503 u64 lim = ch_N(parent);
504 if (elem_idx < lim) {
505 u64 &elem = ch_qFind(parent, elem_idx); // fetch
506 elem = elem | (u64(1) << shift); // set bit
507 }
508}
509
510// --- algo.Charset.ch.qSetBitVal
511// Set bit # BIT_IDX in bit set. No bounds checking
512inline void algo::ch_qSetBitVal(algo::Charset& parent, u32 bit_idx, bool val) {
513 u64 elem_idx = bit_idx >> 6;
514 u64 shift = bit_idx & 63;
515 u64 &elem = ch_qFind(parent, elem_idx); // fetch
516 elem = (elem & ~(u64(1) << shift)) | (u64(val) << shift); // insert new value
517}
518
519// --- algo.Charset.ch.qOrBitVal
520// Or bit # BIT_IDX in bit set. No bounds checking
521inline void algo::ch_qOrBitVal(algo::Charset& parent, u32 bit_idx, bool val) {
522 u64 elem_idx = bit_idx >> 6;
523 u64 shift = bit_idx & 63;
524 u64 &elem = ch_qFind(parent, elem_idx); // fetch
525 elem = elem | (u64(val) << shift); // Or in val into elem
526}
527
528// --- algo.Charset.ch.ClearBitsAll
529// Set all bits of array to zero.
530// Note: this does not change what NBits will return.
531inline void algo::ch_ClearBitsAll(algo::Charset& parent) {
532 u64 n = ch_N(parent);
533 for (u64 i = 0; i < n; i++) {
534 ch_qFind(parent, i) = 0;
535 }
536}
537
538// --- algo.Charset.ch.ClearBits
539// Zero in PARENT any bits that are set in RHS.
540inline void algo::ch_ClearBits(algo::Charset& parent, algo::Charset &rhs) {
541 u64 n = u64_Min(ch_N(parent), ch_N(rhs));
542 for (u64 i = 0; i < n; i++) {
543 ch_qFind(parent, i) &= ~ch_qFind(rhs, i);
544 }
545}
546
547// --- algo.Charset.ch.OrBits
548// Set PARENT to union of two bitsets.
549// (This function is not named Set.. to avoid triple entendre).
550inline void algo::ch_OrBits(algo::Charset& parent, algo::Charset &rhs) {
551 u64 n = u64_Min(ch_N(parent), ch_N(rhs));
552 for (u64 i = 0; i < n; i++) {
553 ch_qFind(parent, i) |= ch_qFind(rhs, i);
554 }
555}
556
557// --- algo.Charset.ch.Sup
558// Return smallest number N such that indexes of all 1 bits are below N
559inline i32 algo::ch_Sup(algo::Charset& parent) {
560 u64 lim = ch_N(parent);
561 i32 ret = 0;
562 for (int i = lim-1; i >= 0; i--) {
563 u64 &val = ch_qFind(parent, i);
564 if (val) {
565 u32 bitidx = algo::u64_BitScanReverse(val) + 1;
566 ret = i * 64 + bitidx;
567 break;
568 }
569 }
570 return ret;
571}
572
573// --- algo.Charset.ch.Fill
574// Set all elements of fixed array to value RHS
575inline void algo::ch_Fill(algo::Charset& parent, const u64 &rhs) {
576 for (int i = 0; i < 8; i++) {
577 parent.ch_elems[i] = rhs;
578 }
579}
580
581// --- algo.Charset.ch.Find
582// Look up row by row id. Return NULL if out of range
583inline u64* algo::ch_Find(algo::Charset& parent, u64 t) {
584 u64 idx = t;
585 u64 lim = 8;
586 return idx < lim ? parent.ch_elems + idx : NULL; // unsigned comparison with limit
587}
588
589// --- algo.Charset.ch.Getary
590// Access fixed array ch as aryptr.
591inline algo::aryptr<u64> algo::ch_Getary(algo::Charset& parent) {
592 return algo::aryptr<u64>(parent.ch_elems, 8);
593}
594
595// --- algo.Charset.ch.Max
596// Return max number of items in the array
597inline i32 algo::ch_Max(algo::Charset& parent) {
598 (void)parent;
599 return 8;
600}
601
602// --- algo.Charset.ch.N
603// Return number of items in the array
604inline i32 algo::ch_N(const algo::Charset& parent) {
605 (void)parent;//only to avoid -Wunused-parameter
606 return 8;
607}
608
609// --- algo.Charset.ch.Setary
610// Set contents of fixed array to RHS; Input length is trimmed as necessary
611inline void algo::ch_Setary(algo::Charset& parent, const algo::aryptr<u64> &rhs) {
612 int n = 8 < rhs.n_elems ? 8 : rhs.n_elems;
613 for (int i = 0; i < n; i++) {
614 parent.ch_elems[i] = rhs[i];
615 }
616}
617
618// --- algo.Charset.ch.qFind
619// 'quick' Access row by row id. No bounds checking in release.
620inline u64& algo::ch_qFind(algo::Charset& parent, u64 t) {
621 return parent.ch_elems[u64(t)];
622}
623
624// --- algo.Charset.ch_bitcurs.Reset
625inline void algo::Charset_ch_bitcurs_Reset(Charset_ch_bitcurs &curs, algo::Charset &parent) {
626 curs.elems = &ch_qFind(parent,0);
627 curs.n_elems = ch_N(parent);
628 curs.bit = -1;
629 Charset_ch_bitcurs_Next(curs);
630}
631
632// --- algo.Charset.ch_bitcurs.ValidQ
633// cursor points to valid item
634inline bool algo::Charset_ch_bitcurs_ValidQ(Charset_ch_bitcurs &curs) {
635 return curs.bit < curs.n_elems*64;
636}
637
638// --- algo.Charset.ch_bitcurs.Access
639// item access
640inline int& algo::Charset_ch_bitcurs_Access(Charset_ch_bitcurs &curs) {
641 return curs.bit;
642}
643
644// --- algo.Charset.ch_curs.Reset
645// cursor points to valid item
646inline void algo::Charset_ch_curs_Reset(Charset_ch_curs &curs, algo::Charset &parent) {
647 curs.parent = &parent;
648 curs.index = 0;
649}
650
651// --- algo.Charset.ch_curs.ValidQ
652// cursor points to valid item
653inline bool algo::Charset_ch_curs_ValidQ(Charset_ch_curs &curs) {
654 return u64(curs.index) < u64(8);
655}
656
657// --- algo.Charset.ch_curs.Next
658// proceed to next item
659inline void algo::Charset_ch_curs_Next(Charset_ch_curs &curs) {
660 curs.index++;
661}
662
663// --- algo.Charset.ch_curs.Access
664// item access
665inline u64& algo::Charset_ch_curs_Access(Charset_ch_curs &curs) {
666 return ch_qFind((*curs.parent), u64(curs.index));
667}
668
669// --- algo.Charset..Init
670// Set all fields to initial values.
671inline void algo::Charset_Init(algo::Charset& parent) {
672 for (int i = 0; i < 8; i++) {
673 parent.ch_elems[i] = 0;
674 }
675}
676
677inline bool algo::Smallstr150::operator ==(const algo::Smallstr150 &rhs) const {
678 return algo::Smallstr150_Eq(const_cast<algo::Smallstr150&>(*this),const_cast<algo::Smallstr150&>(rhs));
679}
680
681inline bool algo::Smallstr150::operator !=(const algo::Smallstr150 &rhs) const {
682 return !algo::Smallstr150_Eq(const_cast<algo::Smallstr150&>(*this),const_cast<algo::Smallstr150&>(rhs));
683}
684
685inline bool algo::Smallstr150::operator ==(const algo::strptr &rhs) const {
686 return algo::Smallstr150_EqStrptr(const_cast<algo::Smallstr150&>(*this),rhs);
687}
688inline algo::Smallstr150::Smallstr150() {
689 algo::Smallstr150_Init(*this);
690}
691
692
693// --- algo.Smallstr150.ch.Add
694// Append character to string.
695// If there is no space for an extra character, do nothing.
696inline void algo::ch_Add(algo::Smallstr150& parent, char c) {
697 if (parent.n_ch < 150) {
698 parent.ch[parent.n_ch++] = c;
699 }
700}
701
702// --- algo.Smallstr150.ch.AddStrptr
703// Append string to this string.
704// If there is no space for an extra character, trim.
705// If there is no space left, dump core in debug mode.
706inline void algo::ch_AddStrptr(algo::Smallstr150& parent, algo::strptr str) {
707 int n_new = str.n_elems;
708 if (parent.n_ch + n_new > 150) {
709 n_new = 150 - parent.n_ch;
710 }
711 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
712 parent.n_ch = u8(parent.n_ch + n_new);
713}
714
715// --- algo.Smallstr150.ch.Getary
716// Access string as array of chars
717inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr150& parent) {
718 int len = ch_N(parent);
719 algo::aryptr<char> ret((char*)parent.ch, len);
720 return ret;
721}
722
723// --- algo.Smallstr150.ch.HashStrptr
724inline u32 algo::Smallstr150_Hash(u32 prev, const algo::strptr &str) {
725 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
726}
727
728// --- algo.Smallstr150.ch.Init
729inline void algo::ch_Init(algo::Smallstr150 &parent) {
730 parent.n_ch = 0;
731}
732
733// --- algo.Smallstr150.ch.Max
734// always return constant 150
735inline int algo::ch_Max(algo::Smallstr150& parent) {
736 (void)parent;
737 return 150;
738}
739
740// --- algo.Smallstr150.ch.N
741inline int algo::ch_N(const algo::Smallstr150& parent) {
742 u64 ret;
743 ret = parent.n_ch;
744 return int(ret);
745}
746
747// --- algo.Smallstr150.ch.AssignStrptr
748// Copy from strptr (operator=)
749inline void algo::Smallstr150::operator =(const algo::strptr &str) {
750 ch_SetStrptr(*this, str);
751}
752
753// --- algo.Smallstr150.ch.Set
754// Copy from same type
755// Copy value from RHS.
756inline void algo::Smallstr150::operator =(const algo::Smallstr150& parent) {
757 memcpy(ch, parent.ch, parent.n_ch);
758 n_ch = parent.n_ch;
759}
760
761// --- algo.Smallstr150.ch.Ctor
762inline algo::Smallstr150::Smallstr150(const algo::Smallstr150 &rhs) {
763 operator =(rhs);
764}
765
766// --- algo.Smallstr150.ch.CtorStrptr
767inline algo::Smallstr150::Smallstr150(const algo::strptr &rhs) {
768 ch_SetStrptr(*this, rhs);
769}
770
771// --- algo.Smallstr150.ch.Cast
772inline algo::Smallstr150::operator algo::strptr () const {
773 return ch_Getary(*this);
774}
775
776// --- algo.Smallstr150..Cmp
777inline i32 algo::Smallstr150_Cmp(algo::Smallstr150& lhs, algo::Smallstr150& rhs) {
778 i32 retval = 0;
779 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
780 return retval;
781}
782
783// --- algo.Smallstr150..Init
784// Set all fields to initial values.
785inline void algo::Smallstr150_Init(algo::Smallstr150& parent) {
786 parent.n_ch = 0;
787}
788
789// --- algo.Smallstr150..Eq
790inline bool algo::Smallstr150_Eq(algo::Smallstr150& lhs, algo::Smallstr150& rhs) {
791 bool retval = true;
792 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
793 return retval;
794}
795
796// --- algo.Smallstr150..EqStrptr
797inline bool algo::Smallstr150_EqStrptr(const algo::Smallstr150& lhs, const algo::strptr& rhs) {
798 return algo::strptr_Eq(ch_Getary(lhs), rhs);
799}
800inline algo::Comment::Comment(const algo::strptr& in_value)
801 : value(in_value)
802{
803}
804inline algo::Comment::Comment() {
805}
806
807
808// --- algo.Comment.value.Cast
809inline algo::Comment::operator algo::strptr () const {
810 return algo::strptr((*this).value);
811}
812
813// --- algo.Comment..Cmp
814inline i32 algo::Comment_Cmp(algo::Comment& lhs, algo::Comment& rhs) {
815 i32 retval = 0;
816 retval = algo::Smallstr150_Cmp(lhs.value, rhs.value);
817 return retval;
818}
819
820// --- algo.Comment..Eq
821inline bool algo::Comment_Eq(algo::Comment& lhs, algo::Comment& rhs) {
822 bool retval = true;
823 retval = algo::Smallstr150_Eq(lhs.value, rhs.value);
824 return retval;
825}
826
827inline bool algo::Smallstr250::operator ==(const algo::Smallstr250 &rhs) const {
828 return algo::Smallstr250_Eq(const_cast<algo::Smallstr250&>(*this),const_cast<algo::Smallstr250&>(rhs));
829}
830
831inline bool algo::Smallstr250::operator !=(const algo::Smallstr250 &rhs) const {
832 return !algo::Smallstr250_Eq(const_cast<algo::Smallstr250&>(*this),const_cast<algo::Smallstr250&>(rhs));
833}
834
835inline bool algo::Smallstr250::operator ==(const algo::strptr &rhs) const {
836 return algo::Smallstr250_EqStrptr(const_cast<algo::Smallstr250&>(*this),rhs);
837}
838inline algo::Smallstr250::Smallstr250() {
839 algo::Smallstr250_Init(*this);
840}
841
842
843// --- algo.Smallstr250.ch.Add
844// Append character to string.
845// If there is no space for an extra character, do nothing.
846inline void algo::ch_Add(algo::Smallstr250& parent, char c) {
847 if (parent.n_ch < 250) {
848 parent.ch[parent.n_ch++] = c;
849 }
850}
851
852// --- algo.Smallstr250.ch.AddStrptr
853// Append string to this string.
854// If there is no space for an extra character, trim.
855// If there is no space left, dump core in debug mode.
856inline void algo::ch_AddStrptr(algo::Smallstr250& parent, algo::strptr str) {
857 int n_new = str.n_elems;
858 if (parent.n_ch + n_new > 250) {
859 n_new = 250 - parent.n_ch;
860 }
861 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
862 parent.n_ch = u8(parent.n_ch + n_new);
863}
864
865// --- algo.Smallstr250.ch.Getary
866// Access string as array of chars
867inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr250& parent) {
868 int len = ch_N(parent);
869 algo::aryptr<char> ret((char*)parent.ch, len);
870 return ret;
871}
872
873// --- algo.Smallstr250.ch.HashStrptr
874inline u32 algo::Smallstr250_Hash(u32 prev, const algo::strptr &str) {
875 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
876}
877
878// --- algo.Smallstr250.ch.Init
879inline void algo::ch_Init(algo::Smallstr250 &parent) {
880 parent.n_ch = 0;
881}
882
883// --- algo.Smallstr250.ch.Max
884// always return constant 250
885inline int algo::ch_Max(algo::Smallstr250& parent) {
886 (void)parent;
887 return 250;
888}
889
890// --- algo.Smallstr250.ch.N
891inline int algo::ch_N(const algo::Smallstr250& parent) {
892 u64 ret;
893 ret = parent.n_ch;
894 return int(ret);
895}
896
897// --- algo.Smallstr250.ch.AssignStrptr
898// Copy from strptr (operator=)
899inline void algo::Smallstr250::operator =(const algo::strptr &str) {
900 ch_SetStrptr(*this, str);
901}
902
903// --- algo.Smallstr250.ch.Set
904// Copy from same type
905// Copy value from RHS.
906inline void algo::Smallstr250::operator =(const algo::Smallstr250& parent) {
907 memcpy(ch, parent.ch, parent.n_ch);
908 n_ch = parent.n_ch;
909}
910
911// --- algo.Smallstr250.ch.Ctor
912inline algo::Smallstr250::Smallstr250(const algo::Smallstr250 &rhs) {
913 operator =(rhs);
914}
915
916// --- algo.Smallstr250.ch.CtorStrptr
917inline algo::Smallstr250::Smallstr250(const algo::strptr &rhs) {
918 ch_SetStrptr(*this, rhs);
919}
920
921// --- algo.Smallstr250.ch.Cast
922inline algo::Smallstr250::operator algo::strptr () const {
923 return ch_Getary(*this);
924}
925
926// --- algo.Smallstr250..Cmp
927inline i32 algo::Smallstr250_Cmp(algo::Smallstr250& lhs, algo::Smallstr250& rhs) {
928 i32 retval = 0;
929 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
930 return retval;
931}
932
933// --- algo.Smallstr250..Init
934// Set all fields to initial values.
935inline void algo::Smallstr250_Init(algo::Smallstr250& parent) {
936 parent.n_ch = 0;
937}
938
939// --- algo.Smallstr250..Eq
940inline bool algo::Smallstr250_Eq(algo::Smallstr250& lhs, algo::Smallstr250& rhs) {
941 bool retval = true;
942 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
943 return retval;
944}
945
946// --- algo.Smallstr250..EqStrptr
947inline bool algo::Smallstr250_EqStrptr(const algo::Smallstr250& lhs, const algo::strptr& rhs) {
948 return algo::strptr_Eq(ch_Getary(lhs), rhs);
949}
950inline algo::CppExpr::CppExpr(const algo::strptr& in_value)
951 : value(in_value)
952{
953}
954inline algo::CppExpr::CppExpr() {
955}
956
957inline algo::UnTime::UnTime(i64 in_value)
958 : value(in_value)
959{
960}
961
962inline bool algo::UnTime::operator ==(const algo::UnTime &rhs) const {
963 return algo::UnTime_Eq(const_cast<algo::UnTime&>(*this),const_cast<algo::UnTime&>(rhs));
964}
965
966inline bool algo::UnTime::operator !=(const algo::UnTime &rhs) const {
967 return !algo::UnTime_Eq(const_cast<algo::UnTime&>(*this),const_cast<algo::UnTime&>(rhs));
968}
969
970inline bool algo::UnTime::operator <(const algo::UnTime &rhs) const {
971 return algo::UnTime_Lt(const_cast<algo::UnTime&>(*this),const_cast<algo::UnTime&>(rhs));
972}
973
974inline bool algo::UnTime::operator >(const algo::UnTime &rhs) const {
975 return rhs < *this;
976}
977
978inline bool algo::UnTime::operator <=(const algo::UnTime &rhs) const {
979 return !(rhs < *this);
980}
981
982inline bool algo::UnTime::operator >=(const algo::UnTime &rhs) const {
983 return !(*this < rhs);
984}
985inline algo::UnTime::UnTime() {
986 algo::UnTime_Init(*this);
987}
988
989
990// --- algo.UnTime..Hash
991inline u32 algo::UnTime_Hash(u32 prev, algo::UnTime rhs) {
992 prev = i64_Hash(prev, rhs.value);
993 return prev;
994}
995
996// --- algo.UnTime..Lt
997inline bool algo::UnTime_Lt(algo::UnTime lhs, algo::UnTime rhs) {
998 return i64_Lt(lhs.value, rhs.value);
999}
1000
1001// --- algo.UnTime..Cmp
1002inline i32 algo::UnTime_Cmp(algo::UnTime lhs, algo::UnTime rhs) {
1003 i32 retval = 0;
1004 retval = i64_Cmp(lhs.value, rhs.value);
1005 return retval;
1006}
1007
1008// --- algo.UnTime..Init
1009// Set all fields to initial values.
1010inline void algo::UnTime_Init(algo::UnTime& parent) {
1011 parent.value = i64(0);
1012}
1013
1014// --- algo.UnTime..UpdateMax
1015// Attempt to make LHS bigger. Return true if it was changed
1016inline bool algo::UnTime_UpdateMax(algo::UnTime &lhs, algo::UnTime rhs) {
1017 bool retval = lhs < rhs;
1018 if (retval) {
1019 lhs = rhs;
1020 }
1021 return retval;
1022}
1023
1024// --- algo.UnTime..Min
1025// Return the lesser of two values
1026inline algo::UnTime algo::UnTime_Min(algo::UnTime lhs, algo::UnTime rhs) {
1027 return lhs < rhs ? lhs : rhs;
1028}
1029
1030// --- algo.UnTime..UpdateMin
1031// Attempt to make LHS smaller. Return true if it was changed
1032inline bool algo::UnTime_UpdateMin(algo::UnTime &lhs, algo::UnTime rhs) {
1033 bool retval = rhs < lhs;
1034 if (retval) {
1035 lhs = rhs;
1036 }
1037 return retval;
1038}
1039
1040// --- algo.UnTime..Max
1041// Return the greater of two values
1042inline algo::UnTime algo::UnTime_Max(algo::UnTime lhs, algo::UnTime rhs) {
1043 return rhs < lhs ? lhs : rhs;
1044}
1045
1046// --- algo.UnTime..Eq
1047inline bool algo::UnTime_Eq(algo::UnTime lhs, algo::UnTime rhs) {
1048 bool retval = true;
1049 retval = i64_Eq(lhs.value, rhs.value);
1050 return retval;
1051}
1052
1053// --- algo.UnTime..Update
1054// Set value. Return true if new value is different from old value.
1055inline bool algo::UnTime_Update(algo::UnTime &lhs, algo::UnTime rhs) {
1056 bool ret = !UnTime_Eq(lhs, rhs); // compare values
1057 if (ret) {
1058 lhs = rhs; // update
1059 }
1060 return ret;
1061}
1062inline algo::DateCache::DateCache() {
1063}
1064
1065inline algo::DayRange::DayRange(algo::UnTime in_start
1066 ,algo::UnTime in_end)
1067 : start(in_start)
1068 , end(in_end)
1069{
1070}
1071inline algo::DayRange::DayRange() {
1072}
1073
1074inline algo::Decimal::Decimal(i32 in_exponent
1075 ,i64 in_mantissa)
1076 : exponent(in_exponent)
1077 , mantissa(in_mantissa)
1078{
1079}
1080
1081inline bool algo::Decimal::operator ==(const algo::Decimal &rhs) const {
1082 return algo::Decimal_Eq(const_cast<algo::Decimal&>(*this),const_cast<algo::Decimal&>(rhs));
1083}
1084
1085inline bool algo::Decimal::operator !=(const algo::Decimal &rhs) const {
1086 return !algo::Decimal_Eq(const_cast<algo::Decimal&>(*this),const_cast<algo::Decimal&>(rhs));
1087}
1088inline algo::Decimal::Decimal() {
1089 algo::Decimal_Init(*this);
1090}
1091
1092
1093// --- algo.Decimal..Cmp
1094inline i32 algo::Decimal_Cmp(algo::Decimal lhs, algo::Decimal rhs) {
1095 i32 retval = 0;
1096 retval = i32_Cmp(lhs.exponent, rhs.exponent);
1097 if (retval != 0) {
1098 return retval;
1099 }
1100 retval = i64_Cmp(lhs.mantissa, rhs.mantissa);
1101 return retval;
1102}
1103
1104// --- algo.Decimal..Init
1105// Set all fields to initial values.
1106inline void algo::Decimal_Init(algo::Decimal& parent) {
1107 parent.exponent = i32(0);
1108 parent.mantissa = i64(0);
1109}
1110
1111// --- algo.Decimal..Eq
1112inline bool algo::Decimal_Eq(algo::Decimal lhs, algo::Decimal rhs) {
1113 bool retval = true;
1114 retval = i32_Eq(lhs.exponent, rhs.exponent);
1115 if (!retval) {
1116 return false;
1117 }
1118 retval = i64_Eq(lhs.mantissa, rhs.mantissa);
1119 return retval;
1120}
1121inline algo::DirEntry::DirEntry() {
1122 algo::DirEntry_Init(*this);
1123}
1124
1125inline algo::DirEntry::~DirEntry() {
1126 algo::DirEntry_Uninit(*this);
1127}
1128
1129inline algo::DryrunQ::DryrunQ(bool in_value)
1130 : value(in_value)
1131{
1132}
1133inline algo::DryrunQ::DryrunQ() {
1134 algo::DryrunQ_Init(*this);
1135}
1136
1137
1138// --- algo.DryrunQ.value.Cast
1139inline algo::DryrunQ::operator bool () const {
1140 return bool((*this).value);
1141}
1142
1143// --- algo.DryrunQ..Init
1144// Set all fields to initial values.
1145inline void algo::DryrunQ_Init(algo::DryrunQ& parent) {
1146 parent.value = bool(false);
1147}
1148inline algo::EchoQ::EchoQ(bool in_value)
1149 : value(in_value)
1150{
1151}
1152inline algo::EchoQ::EchoQ(algo_EchoQEnum arg) { this->value = bool(arg); }
1153inline algo::EchoQ::EchoQ() {
1154 algo::EchoQ_Init(*this);
1155}
1156
1157
1158// --- algo.EchoQ.value.GetEnum
1159// Get value of field as enum type
1160inline algo_EchoQEnum algo::value_GetEnum(const algo::EchoQ& parent) {
1161 return algo_EchoQEnum(parent.value);
1162}
1163
1164// --- algo.EchoQ.value.SetEnum
1165// Set value of field from enum type.
1166inline void algo::value_SetEnum(algo::EchoQ& parent, algo_EchoQEnum rhs) {
1167 parent.value = bool(rhs);
1168}
1169
1170// --- algo.EchoQ.value.Cast
1171inline algo::EchoQ::operator algo_EchoQEnum () const {
1172 return algo_EchoQEnum((*this).value);
1173}
1174
1175// --- algo.EchoQ..Init
1176// Set all fields to initial values.
1177inline void algo::EchoQ_Init(algo::EchoQ& parent) {
1178 parent.value = bool(false);
1179}
1180inline algo::Errns::Errns(u8 in_value)
1181 : value(in_value)
1182{
1183}
1184inline algo::Errns::Errns(algo_ErrnsEnum arg) { this->value = u8(arg); }
1185inline algo::Errns::Errns() {
1186 algo::Errns_Init(*this);
1187}
1188
1189
1190// --- algo.Errns.value.GetEnum
1191// Get value of field as enum type
1192inline algo_ErrnsEnum algo::value_GetEnum(const algo::Errns& parent) {
1193 return algo_ErrnsEnum(parent.value);
1194}
1195
1196// --- algo.Errns.value.SetEnum
1197// Set value of field from enum type.
1198inline void algo::value_SetEnum(algo::Errns& parent, algo_ErrnsEnum rhs) {
1199 parent.value = u8(rhs);
1200}
1201
1202// --- algo.Errns.value.Cast
1203inline algo::Errns::operator algo_ErrnsEnum () const {
1204 return algo_ErrnsEnum((*this).value);
1205}
1206
1207// --- algo.Errns..Init
1208// Set all fields to initial values.
1209inline void algo::Errns_Init(algo::Errns& parent) {
1210 parent.value = u8(0);
1211}
1212inline algo::Errcode::Errcode() {
1213 algo::Errcode_Init(*this);
1214}
1215
1216
1217// --- algo.Errcode.code.Get
1218// Retrieve bitfield from value of field value
1219// 32 bits starting at bit 0.
1220inline i32 algo::code_Get(const algo::Errcode& parent) {
1221 return i32((parent.value >> 0) & 0xffffffff);
1222}
1223
1224// --- algo.Errcode.code.Set
1225// Set bitfield in value of field 'value'
1226// 32 bits starting at bit 0.
1227inline void algo::code_Set(algo::Errcode& parent, i32 rhs) {
1228 u64 t1 = u64(0xffffffff) << 0;
1229 u64 t2 = (u64(rhs) & 0xffffffff) << 0;
1230 parent.value = u64((parent.value & ~t1) | t2);
1231}
1232
1233// --- algo.Errcode.type.Get
1234// Retrieve bitfield from value of field value
1235// 8 bits starting at bit 32.
1236inline algo::Errns algo::type_Get(const algo::Errcode& parent) {
1237 return algo::Errns((parent.value >> 32) & 0xff);
1238}
1239
1240// --- algo.Errcode.type.Set
1241// Set bitfield in value of field 'value'
1242// 8 bits starting at bit 32.
1243inline void algo::type_Set(algo::Errcode& parent, algo::Errns rhs) {
1244 u64 t1 = u64(0xff) << 32;
1245 u64 t2 = (u64(rhs.value) & 0xff) << 32;
1246 parent.value = u64((parent.value & ~t1) | t2);
1247}
1248
1249// --- algo.Errcode..Init
1250// Set all fields to initial values.
1251inline void algo::Errcode_Init(algo::Errcode& parent) {
1252 parent.value = u64(0);
1253}
1254inline algo::FailokQ::FailokQ(bool in_value)
1255 : value(in_value)
1256{
1257}
1258inline algo::FailokQ::FailokQ(algo_FailokQEnum arg) { this->value = bool(arg); }
1259inline algo::FailokQ::FailokQ() {
1260 algo::FailokQ_Init(*this);
1261}
1262
1263
1264// --- algo.FailokQ.value.GetEnum
1265// Get value of field as enum type
1266inline algo_FailokQEnum algo::value_GetEnum(const algo::FailokQ& parent) {
1267 return algo_FailokQEnum(parent.value);
1268}
1269
1270// --- algo.FailokQ.value.SetEnum
1271// Set value of field from enum type.
1272inline void algo::value_SetEnum(algo::FailokQ& parent, algo_FailokQEnum rhs) {
1273 parent.value = bool(rhs);
1274}
1275
1276// --- algo.FailokQ.value.Cast
1277inline algo::FailokQ::operator algo_FailokQEnum () const {
1278 return algo_FailokQEnum((*this).value);
1279}
1280
1281// --- algo.FailokQ..Init
1282// Set all fields to initial values.
1283inline void algo::FailokQ_Init(algo::FailokQ& parent) {
1284 parent.value = bool(false);
1285}
1286inline algo::FieldId::FieldId(i32 in_value)
1287 : value(in_value)
1288{
1289}
1290inline algo::FieldId::FieldId(algo_FieldIdEnum arg) { this->value = i32(arg); }
1291inline algo::FieldId::FieldId() {
1292 algo::FieldId_Init(*this);
1293}
1294
1295
1296// --- algo.FieldId.value.GetEnum
1297// Get value of field as enum type
1298inline algo_FieldIdEnum algo::value_GetEnum(const algo::FieldId& parent) {
1299 return algo_FieldIdEnum(parent.value);
1300}
1301
1302// --- algo.FieldId.value.SetEnum
1303// Set value of field from enum type.
1304inline void algo::value_SetEnum(algo::FieldId& parent, algo_FieldIdEnum rhs) {
1305 parent.value = i32(rhs);
1306}
1307
1308// --- algo.FieldId.value.Cast
1309inline algo::FieldId::operator algo_FieldIdEnum () const {
1310 return algo_FieldIdEnum((*this).value);
1311}
1312
1313// --- algo.FieldId..Init
1314// Set all fields to initial values.
1315inline void algo::FieldId_Init(algo::FieldId& parent) {
1316 parent.value = i32(-1);
1317}
1318inline algo::Fildes::Fildes(i32 in_value)
1319 : value(in_value)
1320{
1321}
1322
1323inline bool algo::Fildes::operator ==(const algo::Fildes &rhs) const {
1324 return algo::Fildes_Eq(const_cast<algo::Fildes&>(*this),const_cast<algo::Fildes&>(rhs));
1325}
1326
1327inline bool algo::Fildes::operator !=(const algo::Fildes &rhs) const {
1328 return !algo::Fildes_Eq(const_cast<algo::Fildes&>(*this),const_cast<algo::Fildes&>(rhs));
1329}
1330
1331inline bool algo::Fildes::operator <(const algo::Fildes &rhs) const {
1332 return algo::Fildes_Lt(const_cast<algo::Fildes&>(*this),const_cast<algo::Fildes&>(rhs));
1333}
1334
1335inline bool algo::Fildes::operator >(const algo::Fildes &rhs) const {
1336 return rhs < *this;
1337}
1338
1339inline bool algo::Fildes::operator <=(const algo::Fildes &rhs) const {
1340 return !(rhs < *this);
1341}
1342
1343inline bool algo::Fildes::operator >=(const algo::Fildes &rhs) const {
1344 return !(*this < rhs);
1345}
1346inline algo::Fildes::Fildes() {
1347 algo::Fildes_Init(*this);
1348}
1349
1350
1351// --- algo.Fildes..Hash
1352inline u32 algo::Fildes_Hash(u32 prev, const algo::Fildes & rhs) {
1353 prev = i32_Hash(prev, rhs.value);
1354 return prev;
1355}
1356
1357// --- algo.Fildes..Lt
1358inline bool algo::Fildes_Lt(algo::Fildes& lhs, algo::Fildes& rhs) {
1359 return i32_Lt(lhs.value, rhs.value);
1360}
1361
1362// --- algo.Fildes..Cmp
1363inline i32 algo::Fildes_Cmp(algo::Fildes& lhs, algo::Fildes& rhs) {
1364 i32 retval = 0;
1365 retval = i32_Cmp(lhs.value, rhs.value);
1366 return retval;
1367}
1368
1369// --- algo.Fildes..Init
1370// Set all fields to initial values.
1371inline void algo::Fildes_Init(algo::Fildes& parent) {
1372 parent.value = i32(-1);
1373}
1374
1375// --- algo.Fildes..Eq
1376inline bool algo::Fildes_Eq(algo::Fildes& lhs, algo::Fildes& rhs) {
1377 bool retval = true;
1378 retval = i32_Eq(lhs.value, rhs.value);
1379 return retval;
1380}
1381
1382// --- algo.Fildes..Update
1383// Set value. Return true if new value is different from old value.
1384inline bool algo::Fildes_Update(algo::Fildes &lhs, algo::Fildes& rhs) {
1385 bool ret = !Fildes_Eq(lhs, rhs); // compare values
1386 if (ret) {
1387 lhs = rhs; // update
1388 }
1389 return ret;
1390}
1391inline algo::FileFlags::FileFlags(u32 in_value)
1392 : value(in_value)
1393{
1394}
1395inline algo::FileFlags::FileFlags(algo_FileFlagsEnum arg) { this->value = u32(arg); }
1396inline algo::FileFlags::FileFlags() {
1397 algo::FileFlags_Init(*this);
1398}
1399
1400
1401// --- algo.FileFlags.value.Cast
1402inline algo::FileFlags::operator algo_FileFlagsEnum () const {
1403 return algo_FileFlagsEnum((*this).value);
1404}
1405
1406// --- algo.FileFlags.append.Get
1407// Retrieve bitfield from value of field value
1408// 1 bits starting at bit 4.
1409inline bool algo::append_Get(const algo::FileFlags& parent) {
1410 return bool((parent.value >> 4) & 0x01);
1411}
1412
1413// --- algo.FileFlags.append.Set
1414// Set bitfield in value of field 'value'
1415// 1 bits starting at bit 4.
1416inline void algo::append_Set(algo::FileFlags& parent, bool rhs) {
1417 u32 t1 = u32(0x01) << 4;
1418 u32 t2 = (u32(rhs) & 0x01) << 4;
1419 parent.value = u32((parent.value & ~t1) | t2);
1420}
1421
1422// --- algo.FileFlags.read.Get
1423// Retrieve bitfield from value of field value
1424// 1 bits starting at bit 0.
1425inline bool algo::read_Get(const algo::FileFlags& parent) {
1426 return bool((parent.value >> 0) & 0x01);
1427}
1428
1429// --- algo.FileFlags.read.Set
1430// Set bitfield in value of field 'value'
1431// 1 bits starting at bit 0.
1432inline void algo::read_Set(algo::FileFlags& parent, bool rhs) {
1433 u32 t1 = u32(0x01) << 0;
1434 u32 t2 = (u32(rhs) & 0x01) << 0;
1435 parent.value = u32((parent.value & ~t1) | t2);
1436}
1437
1438// --- algo.FileFlags.write.Get
1439// Retrieve bitfield from value of field value
1440// 1 bits starting at bit 1.
1441inline bool algo::write_Get(const algo::FileFlags& parent) {
1442 return bool((parent.value >> 1) & 0x01);
1443}
1444
1445// --- algo.FileFlags.write.Set
1446// Set bitfield in value of field 'value'
1447// 1 bits starting at bit 1.
1448inline void algo::write_Set(algo::FileFlags& parent, bool rhs) {
1449 u32 t1 = u32(0x01) << 1;
1450 u32 t2 = (u32(rhs) & 0x01) << 1;
1451 parent.value = u32((parent.value & ~t1) | t2);
1452}
1453
1454// --- algo.FileFlags._throw.Get
1455// Retrieve bitfield from value of field value
1456// 1 bits starting at bit 5.
1457inline bool algo::_throw_Get(const algo::FileFlags& parent) {
1458 return bool((parent.value >> 5) & 0x01);
1459}
1460
1461// --- algo.FileFlags._throw.Set
1462// Set bitfield in value of field 'value'
1463// 1 bits starting at bit 5.
1464inline void algo::_throw_Set(algo::FileFlags& parent, bool rhs) {
1465 u32 t1 = u32(0x01) << 5;
1466 u32 t2 = (u32(rhs) & 0x01) << 5;
1467 parent.value = u32((parent.value & ~t1) | t2);
1468}
1469
1470// --- algo.FileFlags.temp.Get
1471// Retrieve bitfield from value of field value
1472// 1 bits starting at bit 6.
1473inline bool algo::temp_Get(const algo::FileFlags& parent) {
1474 return bool((parent.value >> 6) & 0x01);
1475}
1476
1477// --- algo.FileFlags.temp.Set
1478// Set bitfield in value of field 'value'
1479// 1 bits starting at bit 6.
1480inline void algo::temp_Set(algo::FileFlags& parent, bool rhs) {
1481 u32 t1 = u32(0x01) << 6;
1482 u32 t2 = (u32(rhs) & 0x01) << 6;
1483 parent.value = u32((parent.value & ~t1) | t2);
1484}
1485
1486// --- algo.FileFlags.overlap.Get
1487// Retrieve bitfield from value of field value
1488// 1 bits starting at bit 7.
1489inline bool algo::overlap_Get(const algo::FileFlags& parent) {
1490 return bool((parent.value >> 7) & 0x01);
1491}
1492
1493// --- algo.FileFlags.overlap.Set
1494// Set bitfield in value of field 'value'
1495// 1 bits starting at bit 7.
1496inline void algo::overlap_Set(algo::FileFlags& parent, bool rhs) {
1497 u32 t1 = u32(0x01) << 7;
1498 u32 t2 = (u32(rhs) & 0x01) << 7;
1499 parent.value = u32((parent.value & ~t1) | t2);
1500}
1501
1502// --- algo.FileFlags.linear.Get
1503// Retrieve bitfield from value of field value
1504// 1 bits starting at bit 8.
1505inline bool algo::linear_Get(const algo::FileFlags& parent) {
1506 return bool((parent.value >> 8) & 0x01);
1507}
1508
1509// --- algo.FileFlags.linear.Set
1510// Set bitfield in value of field 'value'
1511// 1 bits starting at bit 8.
1512inline void algo::linear_Set(algo::FileFlags& parent, bool rhs) {
1513 u32 t1 = u32(0x01) << 8;
1514 u32 t2 = (u32(rhs) & 0x01) << 8;
1515 parent.value = u32((parent.value & ~t1) | t2);
1516}
1517
1518// --- algo.FileFlags.printerr.Get
1519// Retrieve bitfield from value of field value
1520// 1 bits starting at bit 9.
1521inline bool algo::printerr_Get(const algo::FileFlags& parent) {
1522 return bool((parent.value >> 9) & 0x01);
1523}
1524
1525// --- algo.FileFlags.printerr.Set
1526// Set bitfield in value of field 'value'
1527// 1 bits starting at bit 9.
1528inline void algo::printerr_Set(algo::FileFlags& parent, bool rhs) {
1529 u32 t1 = u32(0x01) << 9;
1530 u32 t2 = (u32(rhs) & 0x01) << 9;
1531 parent.value = u32((parent.value & ~t1) | t2);
1532}
1533
1534// --- algo.FileFlags..Init
1535// Set all fields to initial values.
1536inline void algo::FileFlags_Init(algo::FileFlags& parent) {
1537 parent.value = u32(0);
1538}
1539inline algo::I32Dec1::I32Dec1(i32 in_value)
1540 : value(in_value)
1541{
1542}
1543inline algo::I32Dec1::I32Dec1() {
1544 algo::I32Dec1_Init(*this);
1545}
1546
1547
1548// --- algo.I32Dec1.value.qSetDouble
1549// Set value of field value.
1550// The value is rounded to the nearest integer.
1551// This ensures that truncation of a near-integer value does not occur.
1552// Example: 1.3 cannot be represented exactly as a double, the actual
1553// stored value will be 1.29999999. when we apply C truncation,
1554// we want to end up with 1.3, not 1.2.
1555inline void algo::value_qSetDouble(algo::I32Dec1& parent, double val) {
1556 double intval = val * 10 + (val > 0 ? 0.5 : -0.5);
1557 // set underlying field.
1558 parent.value = intval;
1559}
1560
1561// --- algo.I32Dec1.value.GetDouble
1562inline double algo::value_GetDouble(const algo::I32Dec1& parent) {
1563 double ret;
1564 ret = parent.value / double(10);
1565 return ret;
1566}
1567
1568// --- algo.I32Dec1.value.GetInt
1569// Return integer portion (divide number by 10)
1570inline i32 algo::value_GetInt(const algo::I32Dec1& parent) {
1571 i32 ret;
1572 ret = parent.value / 10;
1573 return ret;
1574}
1575
1576// --- algo.I32Dec1.value.GetScale
1577// Return constant 10
1578inline i32 algo::I32Dec1_GetScale() {
1579 return 10;
1580}
1581
1582// --- algo.I32Dec1.value.Cast
1583inline algo::I32Dec1::operator i32 () const {
1584 return i32((*this).value);
1585}
1586
1587// --- algo.I32Dec1..Hash
1588inline u32 algo::I32Dec1_Hash(u32 prev, algo::I32Dec1 rhs) {
1589 prev = i32_Hash(prev, rhs.value);
1590 return prev;
1591}
1592
1593// --- algo.I32Dec1..Init
1594// Set all fields to initial values.
1595inline void algo::I32Dec1_Init(algo::I32Dec1& parent) {
1596 parent.value = i32(0);
1597}
1598inline algo::I32Dec2::I32Dec2(i32 in_value)
1599 : value(in_value)
1600{
1601}
1602inline algo::I32Dec2::I32Dec2() {
1603 algo::I32Dec2_Init(*this);
1604}
1605
1606
1607// --- algo.I32Dec2.value.qSetDouble
1608// Set value of field value.
1609// The value is rounded to the nearest integer.
1610// This ensures that truncation of a near-integer value does not occur.
1611// Example: 1.3 cannot be represented exactly as a double, the actual
1612// stored value will be 1.29999999. when we apply C truncation,
1613// we want to end up with 1.3, not 1.2.
1614inline void algo::value_qSetDouble(algo::I32Dec2& parent, double val) {
1615 double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
1616 // set underlying field.
1617 parent.value = intval;
1618}
1619
1620// --- algo.I32Dec2.value.GetDouble
1621inline double algo::value_GetDouble(const algo::I32Dec2& parent) {
1622 double ret;
1623 ret = parent.value / double(100);
1624 return ret;
1625}
1626
1627// --- algo.I32Dec2.value.GetInt
1628// Return integer portion (divide number by 100)
1629inline i32 algo::value_GetInt(const algo::I32Dec2& parent) {
1630 i32 ret;
1631 ret = parent.value / 100;
1632 return ret;
1633}
1634
1635// --- algo.I32Dec2.value.GetScale
1636// Return constant 100
1637inline i32 algo::I32Dec2_GetScale() {
1638 return 100;
1639}
1640
1641// --- algo.I32Dec2.value.Cast
1642inline algo::I32Dec2::operator i32 () const {
1643 return i32((*this).value);
1644}
1645
1646// --- algo.I32Dec2..Hash
1647inline u32 algo::I32Dec2_Hash(u32 prev, algo::I32Dec2 rhs) {
1648 prev = i32_Hash(prev, rhs.value);
1649 return prev;
1650}
1651
1652// --- algo.I32Dec2..Init
1653// Set all fields to initial values.
1654inline void algo::I32Dec2_Init(algo::I32Dec2& parent) {
1655 parent.value = i32(0);
1656}
1657inline algo::I32Dec3::I32Dec3(i32 in_value)
1658 : value(in_value)
1659{
1660}
1661inline algo::I32Dec3::I32Dec3() {
1662 algo::I32Dec3_Init(*this);
1663}
1664
1665
1666// --- algo.I32Dec3.value.qSetDouble
1667// Set value of field value.
1668// The value is rounded to the nearest integer.
1669// This ensures that truncation of a near-integer value does not occur.
1670// Example: 1.3 cannot be represented exactly as a double, the actual
1671// stored value will be 1.29999999. when we apply C truncation,
1672// we want to end up with 1.3, not 1.2.
1673inline void algo::value_qSetDouble(algo::I32Dec3& parent, double val) {
1674 double intval = val * 1000 + (val > 0 ? 0.5 : -0.5);
1675 // set underlying field.
1676 parent.value = intval;
1677}
1678
1679// --- algo.I32Dec3.value.GetDouble
1680inline double algo::value_GetDouble(const algo::I32Dec3& parent) {
1681 double ret;
1682 ret = parent.value / double(1000);
1683 return ret;
1684}
1685
1686// --- algo.I32Dec3.value.GetInt
1687// Return integer portion (divide number by 1000)
1688inline i32 algo::value_GetInt(const algo::I32Dec3& parent) {
1689 i32 ret;
1690 ret = parent.value / 1000;
1691 return ret;
1692}
1693
1694// --- algo.I32Dec3.value.GetScale
1695// Return constant 1000
1696inline i32 algo::I32Dec3_GetScale() {
1697 return 1000;
1698}
1699
1700// --- algo.I32Dec3.value.Cast
1701inline algo::I32Dec3::operator i32 () const {
1702 return i32((*this).value);
1703}
1704
1705// --- algo.I32Dec3..Hash
1706inline u32 algo::I32Dec3_Hash(u32 prev, algo::I32Dec3 rhs) {
1707 prev = i32_Hash(prev, rhs.value);
1708 return prev;
1709}
1710
1711// --- algo.I32Dec3..Init
1712// Set all fields to initial values.
1713inline void algo::I32Dec3_Init(algo::I32Dec3& parent) {
1714 parent.value = i32(0);
1715}
1716inline algo::I32Dec4::I32Dec4(i32 in_value)
1717 : value(in_value)
1718{
1719}
1720inline algo::I32Dec4::I32Dec4() {
1721 algo::I32Dec4_Init(*this);
1722}
1723
1724
1725// --- algo.I32Dec4.value.qSetDouble
1726// Set value of field value.
1727// The value is rounded to the nearest integer.
1728// This ensures that truncation of a near-integer value does not occur.
1729// Example: 1.3 cannot be represented exactly as a double, the actual
1730// stored value will be 1.29999999. when we apply C truncation,
1731// we want to end up with 1.3, not 1.2.
1732inline void algo::value_qSetDouble(algo::I32Dec4& parent, double val) {
1733 double intval = val * 10000 + (val > 0 ? 0.5 : -0.5);
1734 // set underlying field.
1735 parent.value = intval;
1736}
1737
1738// --- algo.I32Dec4.value.GetDouble
1739inline double algo::value_GetDouble(const algo::I32Dec4& parent) {
1740 double ret;
1741 ret = parent.value / double(10000);
1742 return ret;
1743}
1744
1745// --- algo.I32Dec4.value.GetInt
1746// Return integer portion (divide number by 10000)
1747inline i32 algo::value_GetInt(const algo::I32Dec4& parent) {
1748 i32 ret;
1749 ret = parent.value / 10000;
1750 return ret;
1751}
1752
1753// --- algo.I32Dec4.value.GetScale
1754// Return constant 10000
1755inline i32 algo::I32Dec4_GetScale() {
1756 return 10000;
1757}
1758
1759// --- algo.I32Dec4.value.Cast
1760inline algo::I32Dec4::operator i32 () const {
1761 return i32((*this).value);
1762}
1763
1764// --- algo.I32Dec4..Hash
1765inline u32 algo::I32Dec4_Hash(u32 prev, algo::I32Dec4 rhs) {
1766 prev = i32_Hash(prev, rhs.value);
1767 return prev;
1768}
1769
1770// --- algo.I32Dec4..Init
1771// Set all fields to initial values.
1772inline void algo::I32Dec4_Init(algo::I32Dec4& parent) {
1773 parent.value = i32(0);
1774}
1775inline algo::I32Dec5::I32Dec5(i32 in_value)
1776 : value(in_value)
1777{
1778}
1779inline algo::I32Dec5::I32Dec5() {
1780 algo::I32Dec5_Init(*this);
1781}
1782
1783
1784// --- algo.I32Dec5.value.qSetDouble
1785// Set value of field value.
1786// The value is rounded to the nearest integer.
1787// This ensures that truncation of a near-integer value does not occur.
1788// Example: 1.3 cannot be represented exactly as a double, the actual
1789// stored value will be 1.29999999. when we apply C truncation,
1790// we want to end up with 1.3, not 1.2.
1791inline void algo::value_qSetDouble(algo::I32Dec5& parent, double val) {
1792 double intval = val * 100000 + (val > 0 ? 0.5 : -0.5);
1793 // set underlying field.
1794 parent.value = intval;
1795}
1796
1797// --- algo.I32Dec5.value.GetDouble
1798inline double algo::value_GetDouble(const algo::I32Dec5& parent) {
1799 double ret;
1800 ret = parent.value / double(100000);
1801 return ret;
1802}
1803
1804// --- algo.I32Dec5.value.GetInt
1805// Return integer portion (divide number by 100000)
1806inline i32 algo::value_GetInt(const algo::I32Dec5& parent) {
1807 i32 ret;
1808 ret = parent.value / 100000;
1809 return ret;
1810}
1811
1812// --- algo.I32Dec5.value.GetScale
1813// Return constant 100000
1814inline i32 algo::I32Dec5_GetScale() {
1815 return 100000;
1816}
1817
1818// --- algo.I32Dec5.value.Cast
1819inline algo::I32Dec5::operator i32 () const {
1820 return i32((*this).value);
1821}
1822
1823// --- algo.I32Dec5..Hash
1824inline u32 algo::I32Dec5_Hash(u32 prev, algo::I32Dec5 rhs) {
1825 prev = i32_Hash(prev, rhs.value);
1826 return prev;
1827}
1828
1829// --- algo.I32Dec5..Init
1830// Set all fields to initial values.
1831inline void algo::I32Dec5_Init(algo::I32Dec5& parent) {
1832 parent.value = i32(0);
1833}
1834inline algo::I64Dec1::I64Dec1(i64 in_value)
1835 : value(in_value)
1836{
1837}
1838inline algo::I64Dec1::I64Dec1() {
1839 algo::I64Dec1_Init(*this);
1840}
1841
1842
1843// --- algo.I64Dec1.value.qSetDouble
1844// Set value of field value.
1845// The value is rounded to the nearest integer.
1846// This ensures that truncation of a near-integer value does not occur.
1847// Example: 1.3 cannot be represented exactly as a double, the actual
1848// stored value will be 1.29999999. when we apply C truncation,
1849// we want to end up with 1.3, not 1.2.
1850inline void algo::value_qSetDouble(algo::I64Dec1& parent, double val) {
1851 double intval = val * 10 + (val > 0 ? 0.5 : -0.5);
1852 // set underlying field.
1853 parent.value = intval;
1854}
1855
1856// --- algo.I64Dec1.value.GetDouble
1857inline double algo::value_GetDouble(const algo::I64Dec1& parent) {
1858 double ret;
1859 ret = parent.value / double(10);
1860 return ret;
1861}
1862
1863// --- algo.I64Dec1.value.GetInt
1864// Return integer portion (divide number by 10)
1865inline i64 algo::value_GetInt(const algo::I64Dec1& parent) {
1866 i64 ret;
1867 ret = parent.value / 10;
1868 return ret;
1869}
1870
1871// --- algo.I64Dec1.value.GetScale
1872// Return constant 10
1873inline i64 algo::I64Dec1_GetScale() {
1874 return 10;
1875}
1876
1877// --- algo.I64Dec1.value.Cast
1878inline algo::I64Dec1::operator i64 () const {
1879 return i64((*this).value);
1880}
1881
1882// --- algo.I64Dec1..Hash
1883inline u32 algo::I64Dec1_Hash(u32 prev, algo::I64Dec1 rhs) {
1884 prev = i64_Hash(prev, rhs.value);
1885 return prev;
1886}
1887
1888// --- algo.I64Dec1..Init
1889// Set all fields to initial values.
1890inline void algo::I64Dec1_Init(algo::I64Dec1& parent) {
1891 parent.value = i64(0);
1892}
1893inline algo::I64Dec10::I64Dec10(i64 in_value)
1894 : value(in_value)
1895{
1896}
1897inline algo::I64Dec10::I64Dec10() {
1898 algo::I64Dec10_Init(*this);
1899}
1900
1901
1902// --- algo.I64Dec10.value.qSetDouble
1903// Set value of field value.
1904// The value is rounded to the nearest integer.
1905// This ensures that truncation of a near-integer value does not occur.
1906// Example: 1.3 cannot be represented exactly as a double, the actual
1907// stored value will be 1.29999999. when we apply C truncation,
1908// we want to end up with 1.3, not 1.2.
1909inline void algo::value_qSetDouble(algo::I64Dec10& parent, double val) {
1910 double intval = val * 10000000000 + (val > 0 ? 0.5 : -0.5);
1911 // set underlying field.
1912 parent.value = intval;
1913}
1914
1915// --- algo.I64Dec10.value.GetDouble
1916inline double algo::value_GetDouble(const algo::I64Dec10& parent) {
1917 double ret;
1918 ret = parent.value / double(10000000000);
1919 return ret;
1920}
1921
1922// --- algo.I64Dec10.value.GetInt
1923// Return integer portion (divide number by 10000000000)
1924inline i64 algo::value_GetInt(const algo::I64Dec10& parent) {
1925 i64 ret;
1926 ret = parent.value / 10000000000;
1927 return ret;
1928}
1929
1930// --- algo.I64Dec10.value.GetScale
1931// Return constant 10000000000
1932inline i64 algo::I64Dec10_GetScale() {
1933 return 10000000000;
1934}
1935
1936// --- algo.I64Dec10.value.Cast
1937inline algo::I64Dec10::operator i64 () const {
1938 return i64((*this).value);
1939}
1940
1941// --- algo.I64Dec10..Hash
1942inline u32 algo::I64Dec10_Hash(u32 prev, algo::I64Dec10 rhs) {
1943 prev = i64_Hash(prev, rhs.value);
1944 return prev;
1945}
1946
1947// --- algo.I64Dec10..Init
1948// Set all fields to initial values.
1949inline void algo::I64Dec10_Init(algo::I64Dec10& parent) {
1950 parent.value = i64(0);
1951}
1952inline algo::I64Dec2::I64Dec2(i64 in_value)
1953 : value(in_value)
1954{
1955}
1956inline algo::I64Dec2::I64Dec2() {
1957 algo::I64Dec2_Init(*this);
1958}
1959
1960
1961// --- algo.I64Dec2.value.qSetDouble
1962// Set value of field value.
1963// The value is rounded to the nearest integer.
1964// This ensures that truncation of a near-integer value does not occur.
1965// Example: 1.3 cannot be represented exactly as a double, the actual
1966// stored value will be 1.29999999. when we apply C truncation,
1967// we want to end up with 1.3, not 1.2.
1968inline void algo::value_qSetDouble(algo::I64Dec2& parent, double val) {
1969 double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
1970 // set underlying field.
1971 parent.value = intval;
1972}
1973
1974// --- algo.I64Dec2.value.GetDouble
1975inline double algo::value_GetDouble(const algo::I64Dec2& parent) {
1976 double ret;
1977 ret = parent.value / double(100);
1978 return ret;
1979}
1980
1981// --- algo.I64Dec2.value.GetInt
1982// Return integer portion (divide number by 100)
1983inline i64 algo::value_GetInt(const algo::I64Dec2& parent) {
1984 i64 ret;
1985 ret = parent.value / 100;
1986 return ret;
1987}
1988
1989// --- algo.I64Dec2.value.GetScale
1990// Return constant 100
1991inline i64 algo::I64Dec2_GetScale() {
1992 return 100;
1993}
1994
1995// --- algo.I64Dec2.value.Cast
1996inline algo::I64Dec2::operator i64 () const {
1997 return i64((*this).value);
1998}
1999
2000// --- algo.I64Dec2..Hash
2001inline u32 algo::I64Dec2_Hash(u32 prev, algo::I64Dec2 rhs) {
2002 prev = i64_Hash(prev, rhs.value);
2003 return prev;
2004}
2005
2006// --- algo.I64Dec2..Init
2007// Set all fields to initial values.
2008inline void algo::I64Dec2_Init(algo::I64Dec2& parent) {
2009 parent.value = i64(0);
2010}
2011inline algo::I64Dec3::I64Dec3(i64 in_value)
2012 : value(in_value)
2013{
2014}
2015inline algo::I64Dec3::I64Dec3() {
2016 algo::I64Dec3_Init(*this);
2017}
2018
2019
2020// --- algo.I64Dec3.value.qSetDouble
2021// Set value of field value.
2022// The value is rounded to the nearest integer.
2023// This ensures that truncation of a near-integer value does not occur.
2024// Example: 1.3 cannot be represented exactly as a double, the actual
2025// stored value will be 1.29999999. when we apply C truncation,
2026// we want to end up with 1.3, not 1.2.
2027inline void algo::value_qSetDouble(algo::I64Dec3& parent, double val) {
2028 double intval = val * 1000 + (val > 0 ? 0.5 : -0.5);
2029 // set underlying field.
2030 parent.value = intval;
2031}
2032
2033// --- algo.I64Dec3.value.GetDouble
2034inline double algo::value_GetDouble(const algo::I64Dec3& parent) {
2035 double ret;
2036 ret = parent.value / double(1000);
2037 return ret;
2038}
2039
2040// --- algo.I64Dec3.value.GetInt
2041// Return integer portion (divide number by 1000)
2042inline i64 algo::value_GetInt(const algo::I64Dec3& parent) {
2043 i64 ret;
2044 ret = parent.value / 1000;
2045 return ret;
2046}
2047
2048// --- algo.I64Dec3.value.GetScale
2049// Return constant 1000
2050inline i64 algo::I64Dec3_GetScale() {
2051 return 1000;
2052}
2053
2054// --- algo.I64Dec3.value.Cast
2055inline algo::I64Dec3::operator i64 () const {
2056 return i64((*this).value);
2057}
2058
2059// --- algo.I64Dec3..Hash
2060inline u32 algo::I64Dec3_Hash(u32 prev, algo::I64Dec3 rhs) {
2061 prev = i64_Hash(prev, rhs.value);
2062 return prev;
2063}
2064
2065// --- algo.I64Dec3..Init
2066// Set all fields to initial values.
2067inline void algo::I64Dec3_Init(algo::I64Dec3& parent) {
2068 parent.value = i64(0);
2069}
2070inline algo::I64Dec4::I64Dec4(i64 in_value)
2071 : value(in_value)
2072{
2073}
2074inline algo::I64Dec4::I64Dec4() {
2075 algo::I64Dec4_Init(*this);
2076}
2077
2078
2079// --- algo.I64Dec4.value.qSetDouble
2080// Set value of field value.
2081// The value is rounded to the nearest integer.
2082// This ensures that truncation of a near-integer value does not occur.
2083// Example: 1.3 cannot be represented exactly as a double, the actual
2084// stored value will be 1.29999999. when we apply C truncation,
2085// we want to end up with 1.3, not 1.2.
2086inline void algo::value_qSetDouble(algo::I64Dec4& parent, double val) {
2087 double intval = val * 10000 + (val > 0 ? 0.5 : -0.5);
2088 // set underlying field.
2089 parent.value = intval;
2090}
2091
2092// --- algo.I64Dec4.value.GetDouble
2093inline double algo::value_GetDouble(const algo::I64Dec4& parent) {
2094 double ret;
2095 ret = parent.value / double(10000);
2096 return ret;
2097}
2098
2099// --- algo.I64Dec4.value.GetInt
2100// Return integer portion (divide number by 10000)
2101inline i64 algo::value_GetInt(const algo::I64Dec4& parent) {
2102 i64 ret;
2103 ret = parent.value / 10000;
2104 return ret;
2105}
2106
2107// --- algo.I64Dec4.value.GetScale
2108// Return constant 10000
2109inline i64 algo::I64Dec4_GetScale() {
2110 return 10000;
2111}
2112
2113// --- algo.I64Dec4.value.Cast
2114inline algo::I64Dec4::operator i64 () const {
2115 return i64((*this).value);
2116}
2117
2118// --- algo.I64Dec4..Hash
2119inline u32 algo::I64Dec4_Hash(u32 prev, algo::I64Dec4 rhs) {
2120 prev = i64_Hash(prev, rhs.value);
2121 return prev;
2122}
2123
2124// --- algo.I64Dec4..Init
2125// Set all fields to initial values.
2126inline void algo::I64Dec4_Init(algo::I64Dec4& parent) {
2127 parent.value = i64(0);
2128}
2129inline algo::I64Dec5::I64Dec5(i64 in_value)
2130 : value(in_value)
2131{
2132}
2133inline algo::I64Dec5::I64Dec5() {
2134 algo::I64Dec5_Init(*this);
2135}
2136
2137
2138// --- algo.I64Dec5.value.qSetDouble
2139// Set value of field value.
2140// The value is rounded to the nearest integer.
2141// This ensures that truncation of a near-integer value does not occur.
2142// Example: 1.3 cannot be represented exactly as a double, the actual
2143// stored value will be 1.29999999. when we apply C truncation,
2144// we want to end up with 1.3, not 1.2.
2145inline void algo::value_qSetDouble(algo::I64Dec5& parent, double val) {
2146 double intval = val * 100000 + (val > 0 ? 0.5 : -0.5);
2147 // set underlying field.
2148 parent.value = intval;
2149}
2150
2151// --- algo.I64Dec5.value.GetDouble
2152inline double algo::value_GetDouble(const algo::I64Dec5& parent) {
2153 double ret;
2154 ret = parent.value / double(100000);
2155 return ret;
2156}
2157
2158// --- algo.I64Dec5.value.GetInt
2159// Return integer portion (divide number by 100000)
2160inline i64 algo::value_GetInt(const algo::I64Dec5& parent) {
2161 i64 ret;
2162 ret = parent.value / 100000;
2163 return ret;
2164}
2165
2166// --- algo.I64Dec5.value.GetScale
2167// Return constant 100000
2168inline i64 algo::I64Dec5_GetScale() {
2169 return 100000;
2170}
2171
2172// --- algo.I64Dec5.value.Cast
2173inline algo::I64Dec5::operator i64 () const {
2174 return i64((*this).value);
2175}
2176
2177// --- algo.I64Dec5..Hash
2178inline u32 algo::I64Dec5_Hash(u32 prev, algo::I64Dec5 rhs) {
2179 prev = i64_Hash(prev, rhs.value);
2180 return prev;
2181}
2182
2183// --- algo.I64Dec5..Init
2184// Set all fields to initial values.
2185inline void algo::I64Dec5_Init(algo::I64Dec5& parent) {
2186 parent.value = i64(0);
2187}
2188inline algo::I64Dec6::I64Dec6(i64 in_value)
2189 : value(in_value)
2190{
2191}
2192inline algo::I64Dec6::I64Dec6() {
2193 algo::I64Dec6_Init(*this);
2194}
2195
2196
2197// --- algo.I64Dec6.value.qSetDouble
2198// Set value of field value.
2199// The value is rounded to the nearest integer.
2200// This ensures that truncation of a near-integer value does not occur.
2201// Example: 1.3 cannot be represented exactly as a double, the actual
2202// stored value will be 1.29999999. when we apply C truncation,
2203// we want to end up with 1.3, not 1.2.
2204inline void algo::value_qSetDouble(algo::I64Dec6& parent, double val) {
2205 double intval = val * 1000000 + (val > 0 ? 0.5 : -0.5);
2206 // set underlying field.
2207 parent.value = intval;
2208}
2209
2210// --- algo.I64Dec6.value.GetDouble
2211inline double algo::value_GetDouble(const algo::I64Dec6& parent) {
2212 double ret;
2213 ret = parent.value / double(1000000);
2214 return ret;
2215}
2216
2217// --- algo.I64Dec6.value.GetInt
2218// Return integer portion (divide number by 1000000)
2219inline i64 algo::value_GetInt(const algo::I64Dec6& parent) {
2220 i64 ret;
2221 ret = parent.value / 1000000;
2222 return ret;
2223}
2224
2225// --- algo.I64Dec6.value.GetScale
2226// Return constant 1000000
2227inline i64 algo::I64Dec6_GetScale() {
2228 return 1000000;
2229}
2230
2231// --- algo.I64Dec6.value.Cast
2232inline algo::I64Dec6::operator i64 () const {
2233 return i64((*this).value);
2234}
2235
2236// --- algo.I64Dec6..Hash
2237inline u32 algo::I64Dec6_Hash(u32 prev, algo::I64Dec6 rhs) {
2238 prev = i64_Hash(prev, rhs.value);
2239 return prev;
2240}
2241
2242// --- algo.I64Dec6..Init
2243// Set all fields to initial values.
2244inline void algo::I64Dec6_Init(algo::I64Dec6& parent) {
2245 parent.value = i64(0);
2246}
2247inline algo::I64Dec7::I64Dec7(i64 in_value)
2248 : value(in_value)
2249{
2250}
2251inline algo::I64Dec7::I64Dec7() {
2252 algo::I64Dec7_Init(*this);
2253}
2254
2255
2256// --- algo.I64Dec7.value.qSetDouble
2257// Set value of field value.
2258// The value is rounded to the nearest integer.
2259// This ensures that truncation of a near-integer value does not occur.
2260// Example: 1.3 cannot be represented exactly as a double, the actual
2261// stored value will be 1.29999999. when we apply C truncation,
2262// we want to end up with 1.3, not 1.2.
2263inline void algo::value_qSetDouble(algo::I64Dec7& parent, double val) {
2264 double intval = val * 10000000 + (val > 0 ? 0.5 : -0.5);
2265 // set underlying field.
2266 parent.value = intval;
2267}
2268
2269// --- algo.I64Dec7.value.GetDouble
2270inline double algo::value_GetDouble(const algo::I64Dec7& parent) {
2271 double ret;
2272 ret = parent.value / double(10000000);
2273 return ret;
2274}
2275
2276// --- algo.I64Dec7.value.GetInt
2277// Return integer portion (divide number by 10000000)
2278inline i64 algo::value_GetInt(const algo::I64Dec7& parent) {
2279 i64 ret;
2280 ret = parent.value / 10000000;
2281 return ret;
2282}
2283
2284// --- algo.I64Dec7.value.GetScale
2285// Return constant 10000000
2286inline i64 algo::I64Dec7_GetScale() {
2287 return 10000000;
2288}
2289
2290// --- algo.I64Dec7.value.Cast
2291inline algo::I64Dec7::operator i64 () const {
2292 return i64((*this).value);
2293}
2294
2295// --- algo.I64Dec7..Hash
2296inline u32 algo::I64Dec7_Hash(u32 prev, algo::I64Dec7 rhs) {
2297 prev = i64_Hash(prev, rhs.value);
2298 return prev;
2299}
2300
2301// --- algo.I64Dec7..Init
2302// Set all fields to initial values.
2303inline void algo::I64Dec7_Init(algo::I64Dec7& parent) {
2304 parent.value = i64(0);
2305}
2306inline algo::I64Dec8::I64Dec8(i64 in_value)
2307 : value(in_value)
2308{
2309}
2310inline algo::I64Dec8::I64Dec8() {
2311 algo::I64Dec8_Init(*this);
2312}
2313
2314
2315// --- algo.I64Dec8.value.qSetDouble
2316// Set value of field value.
2317// The value is rounded to the nearest integer.
2318// This ensures that truncation of a near-integer value does not occur.
2319// Example: 1.3 cannot be represented exactly as a double, the actual
2320// stored value will be 1.29999999. when we apply C truncation,
2321// we want to end up with 1.3, not 1.2.
2322inline void algo::value_qSetDouble(algo::I64Dec8& parent, double val) {
2323 double intval = val * 100000000 + (val > 0 ? 0.5 : -0.5);
2324 // set underlying field.
2325 parent.value = intval;
2326}
2327
2328// --- algo.I64Dec8.value.GetDouble
2329inline double algo::value_GetDouble(const algo::I64Dec8& parent) {
2330 double ret;
2331 ret = parent.value / double(100000000);
2332 return ret;
2333}
2334
2335// --- algo.I64Dec8.value.GetInt
2336// Return integer portion (divide number by 100000000)
2337inline i64 algo::value_GetInt(const algo::I64Dec8& parent) {
2338 i64 ret;
2339 ret = parent.value / 100000000;
2340 return ret;
2341}
2342
2343// --- algo.I64Dec8.value.GetScale
2344// Return constant 100000000
2345inline i64 algo::I64Dec8_GetScale() {
2346 return 100000000;
2347}
2348
2349// --- algo.I64Dec8.value.Cast
2350inline algo::I64Dec8::operator i64 () const {
2351 return i64((*this).value);
2352}
2353
2354// --- algo.I64Dec8..Hash
2355inline u32 algo::I64Dec8_Hash(u32 prev, algo::I64Dec8 rhs) {
2356 prev = i64_Hash(prev, rhs.value);
2357 return prev;
2358}
2359
2360// --- algo.I64Dec8..Init
2361// Set all fields to initial values.
2362inline void algo::I64Dec8_Init(algo::I64Dec8& parent) {
2363 parent.value = i64(0);
2364}
2365inline algo::I64Dec9::I64Dec9(i64 in_value)
2366 : value(in_value)
2367{
2368}
2369inline algo::I64Dec9::I64Dec9() {
2370 algo::I64Dec9_Init(*this);
2371}
2372
2373
2374// --- algo.I64Dec9.value.qSetDouble
2375// Set value of field value.
2376// The value is rounded to the nearest integer.
2377// This ensures that truncation of a near-integer value does not occur.
2378// Example: 1.3 cannot be represented exactly as a double, the actual
2379// stored value will be 1.29999999. when we apply C truncation,
2380// we want to end up with 1.3, not 1.2.
2381inline void algo::value_qSetDouble(algo::I64Dec9& parent, double val) {
2382 double intval = val * 1000000000 + (val > 0 ? 0.5 : -0.5);
2383 // set underlying field.
2384 parent.value = intval;
2385}
2386
2387// --- algo.I64Dec9.value.GetDouble
2388inline double algo::value_GetDouble(const algo::I64Dec9& parent) {
2389 double ret;
2390 ret = parent.value / double(1000000000);
2391 return ret;
2392}
2393
2394// --- algo.I64Dec9.value.GetInt
2395// Return integer portion (divide number by 1000000000)
2396inline i64 algo::value_GetInt(const algo::I64Dec9& parent) {
2397 i64 ret;
2398 ret = parent.value / 1000000000;
2399 return ret;
2400}
2401
2402// --- algo.I64Dec9.value.GetScale
2403// Return constant 1000000000
2404inline i64 algo::I64Dec9_GetScale() {
2405 return 1000000000;
2406}
2407
2408// --- algo.I64Dec9.value.Cast
2409inline algo::I64Dec9::operator i64 () const {
2410 return i64((*this).value);
2411}
2412
2413// --- algo.I64Dec9..Hash
2414inline u32 algo::I64Dec9_Hash(u32 prev, algo::I64Dec9 rhs) {
2415 prev = i64_Hash(prev, rhs.value);
2416 return prev;
2417}
2418
2419// --- algo.I64Dec9..Init
2420// Set all fields to initial values.
2421inline void algo::I64Dec9_Init(algo::I64Dec9& parent) {
2422 parent.value = i64(0);
2423}
2424inline algo::IOEvtFlags::IOEvtFlags(u32 in_value)
2425 : value(in_value)
2426{
2427}
2428inline algo::IOEvtFlags::IOEvtFlags(algo_IOEvtFlagsEnum arg) { this->value = u32(arg); }
2429inline algo::IOEvtFlags::IOEvtFlags() {
2430 algo::IOEvtFlags_Init(*this);
2431}
2432
2433
2434// --- algo.IOEvtFlags.value.Cast
2435inline algo::IOEvtFlags::operator algo_IOEvtFlagsEnum () const {
2436 return algo_IOEvtFlagsEnum((*this).value);
2437}
2438
2439// --- algo.IOEvtFlags.read.Get
2440// Retrieve bitfield from value of field value
2441// 1 bits starting at bit 0.
2442inline bool algo::read_Get(const algo::IOEvtFlags& parent) {
2443 return bool((parent.value >> 0) & 0x01);
2444}
2445
2446// --- algo.IOEvtFlags.read.Set
2447// Set bitfield in value of field 'value'
2448// 1 bits starting at bit 0.
2449inline void algo::read_Set(algo::IOEvtFlags& parent, bool rhs) {
2450 u32 t1 = u32(0x01) << 0;
2451 u32 t2 = (u32(rhs) & 0x01) << 0;
2452 parent.value = u32((parent.value & ~t1) | t2);
2453}
2454
2455// --- algo.IOEvtFlags.write.Get
2456// Retrieve bitfield from value of field value
2457// 1 bits starting at bit 1.
2458inline bool algo::write_Get(const algo::IOEvtFlags& parent) {
2459 return bool((parent.value >> 1) & 0x01);
2460}
2461
2462// --- algo.IOEvtFlags.write.Set
2463// Set bitfield in value of field 'value'
2464// 1 bits starting at bit 1.
2465inline void algo::write_Set(algo::IOEvtFlags& parent, bool rhs) {
2466 u32 t1 = u32(0x01) << 1;
2467 u32 t2 = (u32(rhs) & 0x01) << 1;
2468 parent.value = u32((parent.value & ~t1) | t2);
2469}
2470
2471// --- algo.IOEvtFlags.eof.Get
2472// Retrieve bitfield from value of field value
2473// 1 bits starting at bit 2.
2474inline bool algo::eof_Get(const algo::IOEvtFlags& parent) {
2475 return bool((parent.value >> 2) & 0x01);
2476}
2477
2478// --- algo.IOEvtFlags.eof.Set
2479// Set bitfield in value of field 'value'
2480// 1 bits starting at bit 2.
2481inline void algo::eof_Set(algo::IOEvtFlags& parent, bool rhs) {
2482 u32 t1 = u32(0x01) << 2;
2483 u32 t2 = (u32(rhs) & 0x01) << 2;
2484 parent.value = u32((parent.value & ~t1) | t2);
2485}
2486
2487// --- algo.IOEvtFlags.err.Get
2488// Retrieve bitfield from value of field value
2489// 1 bits starting at bit 3.
2490inline bool algo::err_Get(const algo::IOEvtFlags& parent) {
2491 return bool((parent.value >> 3) & 0x01);
2492}
2493
2494// --- algo.IOEvtFlags.err.Set
2495// Set bitfield in value of field 'value'
2496// 1 bits starting at bit 3.
2497inline void algo::err_Set(algo::IOEvtFlags& parent, bool rhs) {
2498 u32 t1 = u32(0x01) << 3;
2499 u32 t2 = (u32(rhs) & 0x01) << 3;
2500 parent.value = u32((parent.value & ~t1) | t2);
2501}
2502
2503// --- algo.IOEvtFlags..Init
2504// Set all fields to initial values.
2505inline void algo::IOEvtFlags_Init(algo::IOEvtFlags& parent) {
2506 parent.value = u32(0);
2507}
2508inline algo::IPoint::IPoint() {
2509 algo::IPoint_Init(*this);
2510}
2511
2512
2513// --- algo.IPoint..Init
2514// Set all fields to initial values.
2515inline void algo::IPoint_Init(algo::IPoint& parent) {
2516 parent.x = i32(0);
2517 parent.y = i32(0);
2518}
2519
2520inline bool algo::Smallstr50::operator ==(const algo::Smallstr50 &rhs) const {
2521 return algo::Smallstr50_Eq(const_cast<algo::Smallstr50&>(*this),const_cast<algo::Smallstr50&>(rhs));
2522}
2523
2524inline bool algo::Smallstr50::operator !=(const algo::Smallstr50 &rhs) const {
2525 return !algo::Smallstr50_Eq(const_cast<algo::Smallstr50&>(*this),const_cast<algo::Smallstr50&>(rhs));
2526}
2527
2528inline bool algo::Smallstr50::operator ==(const algo::strptr &rhs) const {
2529 return algo::Smallstr50_EqStrptr(const_cast<algo::Smallstr50&>(*this),rhs);
2530}
2531
2532inline bool algo::Smallstr50::operator <(const algo::Smallstr50 &rhs) const {
2533 return algo::Smallstr50_Lt(const_cast<algo::Smallstr50&>(*this),const_cast<algo::Smallstr50&>(rhs));
2534}
2535
2536inline bool algo::Smallstr50::operator >(const algo::Smallstr50 &rhs) const {
2537 return rhs < *this;
2538}
2539
2540inline bool algo::Smallstr50::operator <=(const algo::Smallstr50 &rhs) const {
2541 return !(rhs < *this);
2542}
2543
2544inline bool algo::Smallstr50::operator >=(const algo::Smallstr50 &rhs) const {
2545 return !(*this < rhs);
2546}
2547inline algo::Smallstr50::Smallstr50() {
2548 algo::Smallstr50_Init(*this);
2549}
2550
2551
2552// --- algo.Smallstr50.ch.Add
2553// Append character to string.
2554// If there is no space for an extra character, do nothing.
2555inline void algo::ch_Add(algo::Smallstr50& parent, char c) {
2556 if (parent.n_ch < 50) {
2557 parent.ch[parent.n_ch++] = c;
2558 }
2559}
2560
2561// --- algo.Smallstr50.ch.AddStrptr
2562// Append string to this string.
2563// If there is no space for an extra character, trim.
2564// If there is no space left, dump core in debug mode.
2565inline void algo::ch_AddStrptr(algo::Smallstr50& parent, algo::strptr str) {
2566 int n_new = str.n_elems;
2567 if (parent.n_ch + n_new > 50) {
2568 n_new = 50 - parent.n_ch;
2569 }
2570 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
2571 parent.n_ch = u8(parent.n_ch + n_new);
2572}
2573
2574// --- algo.Smallstr50.ch.Getary
2575// Access string as array of chars
2576inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr50& parent) {
2577 int len = ch_N(parent);
2578 algo::aryptr<char> ret((char*)parent.ch, len);
2579 return ret;
2580}
2581
2582// --- algo.Smallstr50.ch.HashStrptr
2583inline u32 algo::Smallstr50_Hash(u32 prev, const algo::strptr &str) {
2584 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
2585}
2586
2587// --- algo.Smallstr50.ch.Init
2588inline void algo::ch_Init(algo::Smallstr50 &parent) {
2589 parent.n_ch = 0;
2590}
2591
2592// --- algo.Smallstr50.ch.Max
2593// always return constant 50
2594inline int algo::ch_Max(algo::Smallstr50& parent) {
2595 (void)parent;
2596 return 50;
2597}
2598
2599// --- algo.Smallstr50.ch.N
2600inline int algo::ch_N(const algo::Smallstr50& parent) {
2601 u64 ret;
2602 ret = parent.n_ch;
2603 return int(ret);
2604}
2605
2606// --- algo.Smallstr50.ch.AssignStrptr
2607// Copy from strptr (operator=)
2608inline void algo::Smallstr50::operator =(const algo::strptr &str) {
2609 ch_SetStrptr(*this, str);
2610}
2611
2612// --- algo.Smallstr50.ch.Set
2613// Copy from same type
2614// Copy value from RHS.
2615inline void algo::Smallstr50::operator =(const algo::Smallstr50& parent) {
2616 memcpy(ch, parent.ch, parent.n_ch);
2617 n_ch = parent.n_ch;
2618}
2619
2620// --- algo.Smallstr50.ch.Ctor
2621inline algo::Smallstr50::Smallstr50(const algo::Smallstr50 &rhs) {
2622 operator =(rhs);
2623}
2624
2625// --- algo.Smallstr50.ch.CtorStrptr
2626inline algo::Smallstr50::Smallstr50(const algo::strptr &rhs) {
2627 ch_SetStrptr(*this, rhs);
2628}
2629
2630// --- algo.Smallstr50.ch.Cast
2631inline algo::Smallstr50::operator algo::strptr () const {
2632 return ch_Getary(*this);
2633}
2634
2635// --- algo.Smallstr50..Lt
2636inline bool algo::Smallstr50_Lt(algo::Smallstr50& lhs, algo::Smallstr50& rhs) {
2637 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
2638}
2639
2640// --- algo.Smallstr50..Cmp
2641inline i32 algo::Smallstr50_Cmp(algo::Smallstr50& lhs, algo::Smallstr50& rhs) {
2642 i32 retval = 0;
2643 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
2644 return retval;
2645}
2646
2647// --- algo.Smallstr50..Init
2648// Set all fields to initial values.
2649inline void algo::Smallstr50_Init(algo::Smallstr50& parent) {
2650 parent.n_ch = 0;
2651}
2652
2653// --- algo.Smallstr50..Eq
2654inline bool algo::Smallstr50_Eq(algo::Smallstr50& lhs, algo::Smallstr50& rhs) {
2655 bool retval = true;
2656 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
2657 return retval;
2658}
2659
2660// --- algo.Smallstr50..Update
2661// Set value. Return true if new value is different from old value.
2662inline bool algo::Smallstr50_Update(algo::Smallstr50 &lhs, algo::Smallstr50& rhs) {
2663 bool ret = !Smallstr50_Eq(lhs, rhs); // compare values
2664 if (ret) {
2665 lhs = rhs; // update
2666 }
2667 return ret;
2668}
2669
2670// --- algo.Smallstr50..EqStrptr
2671inline bool algo::Smallstr50_EqStrptr(const algo::Smallstr50& lhs, const algo::strptr& rhs) {
2672 return algo::strptr_Eq(ch_Getary(lhs), rhs);
2673}
2674inline algo::Imdb::Imdb(const algo::strptr& in_imdb
2675 ,const algo::ImdbInsertStrptrMaybeFcn& in_InsertStrptrMaybe
2676 ,const algo::ImdbStepFcn& in_Step
2677 ,const algo::ImdbMainLoopFcn& in_MainLoop
2678 ,const algo::ImdbGetTraceFcn& in_GetTrace
2679 ,const algo::Comment& in_comment)
2680 : imdb(in_imdb)
2681 , InsertStrptrMaybe(in_InsertStrptrMaybe)
2682 , Step(in_Step)
2683 , MainLoop(in_MainLoop)
2684 , GetTrace(in_GetTrace)
2685 , comment(in_comment)
2686{
2687}
2688inline algo::Imdb::Imdb() {
2689 algo::Imdb_Init(*this);
2690}
2691
2692
2693// --- algo.Imdb..Init
2694// Set all fields to initial values.
2695inline void algo::Imdb_Init(algo::Imdb& parent) {
2696 memset(&parent.InsertStrptrMaybe, 0, sizeof(parent.InsertStrptrMaybe));
2697 memset(&parent.Step, 0, sizeof(parent.Step));
2698 memset(&parent.MainLoop, 0, sizeof(parent.MainLoop));
2699 memset(&parent.GetTrace, 0, sizeof(parent.GetTrace));
2700}
2701inline algo::ImrowPtr::ImrowPtr(u64 in_value)
2702 : value(in_value)
2703{
2704}
2705inline algo::ImrowPtr::ImrowPtr() {
2706 algo::ImrowPtr_Init(*this);
2707}
2708
2709
2710// --- algo.ImrowPtr.value.Cast
2711inline algo::ImrowPtr::operator u64 () const {
2712 return u64((*this).value);
2713}
2714
2715// --- algo.ImrowPtr..Init
2716// Set all fields to initial values.
2717inline void algo::ImrowPtr_Init(algo::ImrowPtr& parent) {
2718 parent.value = u64(0);
2719}
2720inline algo::Smallstr100::Smallstr100() {
2721 algo::Smallstr100_Init(*this);
2722}
2723
2724
2725// --- algo.Smallstr100.ch.Add
2726// Append character to string.
2727// If there is no space for an extra character, do nothing.
2728inline void algo::ch_Add(algo::Smallstr100& parent, char c) {
2729 if (parent.n_ch < 100) {
2730 parent.ch[parent.n_ch++] = c;
2731 }
2732}
2733
2734// --- algo.Smallstr100.ch.AddStrptr
2735// Append string to this string.
2736// If there is no space for an extra character, trim.
2737// If there is no space left, dump core in debug mode.
2738inline void algo::ch_AddStrptr(algo::Smallstr100& parent, algo::strptr str) {
2739 int n_new = str.n_elems;
2740 if (parent.n_ch + n_new > 100) {
2741 n_new = 100 - parent.n_ch;
2742 }
2743 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
2744 parent.n_ch = u8(parent.n_ch + n_new);
2745}
2746
2747// --- algo.Smallstr100.ch.Getary
2748// Access string as array of chars
2749inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr100& parent) {
2750 int len = ch_N(parent);
2751 algo::aryptr<char> ret((char*)parent.ch, len);
2752 return ret;
2753}
2754
2755// --- algo.Smallstr100.ch.HashStrptr
2756inline u32 algo::Smallstr100_Hash(u32 prev, const algo::strptr &str) {
2757 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
2758}
2759
2760// --- algo.Smallstr100.ch.Init
2761inline void algo::ch_Init(algo::Smallstr100 &parent) {
2762 parent.n_ch = 0;
2763}
2764
2765// --- algo.Smallstr100.ch.Max
2766// always return constant 100
2767inline int algo::ch_Max(algo::Smallstr100& parent) {
2768 (void)parent;
2769 return 100;
2770}
2771
2772// --- algo.Smallstr100.ch.N
2773inline int algo::ch_N(const algo::Smallstr100& parent) {
2774 u64 ret;
2775 ret = parent.n_ch;
2776 return int(ret);
2777}
2778
2779// --- algo.Smallstr100.ch.AssignStrptr
2780// Copy from strptr (operator=)
2781inline void algo::Smallstr100::operator =(const algo::strptr &str) {
2782 ch_SetStrptr(*this, str);
2783}
2784
2785// --- algo.Smallstr100.ch.Set
2786// Copy from same type
2787// Copy value from RHS.
2788inline void algo::Smallstr100::operator =(const algo::Smallstr100& parent) {
2789 memcpy(ch, parent.ch, parent.n_ch);
2790 n_ch = parent.n_ch;
2791}
2792
2793// --- algo.Smallstr100.ch.Ctor
2794inline algo::Smallstr100::Smallstr100(const algo::Smallstr100 &rhs) {
2795 operator =(rhs);
2796}
2797
2798// --- algo.Smallstr100.ch.CtorStrptr
2799inline algo::Smallstr100::Smallstr100(const algo::strptr &rhs) {
2800 ch_SetStrptr(*this, rhs);
2801}
2802
2803// --- algo.Smallstr100.ch.Cast
2804inline algo::Smallstr100::operator algo::strptr () const {
2805 return ch_Getary(*this);
2806}
2807
2808// --- algo.Smallstr100..Cmp
2809inline i32 algo::Smallstr100_Cmp(algo::Smallstr100& lhs, algo::Smallstr100& rhs) {
2810 i32 retval = 0;
2811 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
2812 return retval;
2813}
2814
2815// --- algo.Smallstr100..Init
2816// Set all fields to initial values.
2817inline void algo::Smallstr100_Init(algo::Smallstr100& parent) {
2818 parent.n_ch = 0;
2819}
2820
2821// --- algo.Smallstr100..Eq
2822inline bool algo::Smallstr100_Eq(algo::Smallstr100& lhs, algo::Smallstr100& rhs) {
2823 bool retval = true;
2824 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
2825 return retval;
2826}
2827
2828// --- algo.Smallstr100..EqStrptr
2829inline bool algo::Smallstr100_EqStrptr(const algo::Smallstr100& lhs, const algo::strptr& rhs) {
2830 return algo::strptr_Eq(ch_Getary(lhs), rhs);
2831}
2832inline algo::Imtable::Imtable(const algo::strptr& in_imtable
2833 ,const algo::strptr& in_elem_type
2834 ,const algo::ImrowRowidFindFcn& in_c_RowidFind
2835 ,const algo::ImrowXrefXFcn& in_XrefX
2836 ,const algo::ImrowNItemsFcn& in_NItems
2837 ,const algo::ImrowPrintFcn& in_Print
2838 ,i32 in_size
2839 ,const algo::strptr& in_ssimfile
2840 ,const algo::Comment& in_comment)
2841 : imtable(in_imtable)
2842 , elem_type(in_elem_type)
2843 , c_RowidFind(in_c_RowidFind)
2844 , XrefX(in_XrefX)
2845 , NItems(in_NItems)
2846 , Print(in_Print)
2847 , size(in_size)
2848 , ssimfile(in_ssimfile)
2849 , comment(in_comment)
2850{
2851}
2852inline algo::Imtable::Imtable() {
2853 algo::Imtable_Init(*this);
2854}
2855
2856
2857// --- algo.Imtable..Init
2858// Set all fields to initial values.
2859inline void algo::Imtable_Init(algo::Imtable& parent) {
2860 memset(&parent.c_RowidFind, 0, sizeof(parent.c_RowidFind));
2861 memset(&parent.XrefX, 0, sizeof(parent.XrefX));
2862 memset(&parent.NItems, 0, sizeof(parent.NItems));
2863 memset(&parent.Print, 0, sizeof(parent.Print));
2864 parent.size = i32(0);
2865}
2866inline algo::Ipmask::Ipmask() {
2867 algo::Ipmask_Init(*this);
2868}
2869
2870
2871// --- algo.Ipmask..Init
2872// Set all fields to initial values.
2873inline void algo::Ipmask_Init(algo::Ipmask& parent) {
2874 parent.ip_host = u32(0);
2875 parent.mask = u32(0);
2876}
2877
2878// --- algo.strptr..Update
2879// Set value. Return true if new value is different from old value.
2880inline bool algo::strptr_Update(algo::strptr &lhs, algo::strptr rhs) {
2881 bool ret = !strptr_Eq(lhs, rhs); // compare values
2882 if (ret) {
2883 lhs = rhs; // update
2884 }
2885 return ret;
2886}
2887inline algo::LineBuf::LineBuf() {
2888 algo::LineBuf_Init(*this);
2889}
2890
2891inline algo::LineBuf::~LineBuf() {
2892 algo::LineBuf_Uninit(*this);
2893}
2894
2895
2896// --- algo.LineBuf.buf.EmptyQ
2897// Return true if index is empty
2898inline bool algo::buf_EmptyQ(algo::LineBuf& parent) {
2899 return parent.buf_n == 0;
2900}
2901
2902// --- algo.LineBuf.buf.Find
2903// Look up row by row id. Return NULL if out of range
2904inline char* algo::buf_Find(algo::LineBuf& parent, u64 t) {
2905 u64 idx = t;
2906 u64 lim = parent.buf_n;
2907 if (idx >= lim) return NULL;
2908 return parent.buf_elems + idx;
2909}
2910
2911// --- algo.LineBuf.buf.Getary
2912// Return array pointer by value
2913inline algo::aryptr<char> algo::buf_Getary(const algo::LineBuf& parent) {
2914 return algo::aryptr<char>(parent.buf_elems, parent.buf_n);
2915}
2916
2917// --- algo.LineBuf.buf.Last
2918// Return pointer to last element of array, or NULL if array is empty
2919inline char* algo::buf_Last(algo::LineBuf& parent) {
2920 return buf_Find(parent, u64(parent.buf_n-1));
2921}
2922
2923// --- algo.LineBuf.buf.Max
2924// Return max. number of items in the array
2925inline i32 algo::buf_Max(algo::LineBuf& parent) {
2926 (void)parent;
2927 return parent.buf_max;
2928}
2929
2930// --- algo.LineBuf.buf.N
2931// Return number of items in the array
2932inline i32 algo::buf_N(const algo::LineBuf& parent) {
2933 return parent.buf_n;
2934}
2935
2936// --- algo.LineBuf.buf.RemoveAll
2937inline void algo::buf_RemoveAll(algo::LineBuf& parent) {
2938 parent.buf_n = 0;
2939}
2940
2941// --- algo.LineBuf.buf.Reserve
2942// Make sure N *more* elements will fit in array. Process dies if out of memory
2943inline void algo::buf_Reserve(algo::LineBuf& parent, int n) {
2944 u32 new_n = parent.buf_n + n;
2945 if (UNLIKELY(new_n > parent.buf_max)) {
2946 buf_AbsReserve(parent, new_n);
2947 }
2948}
2949
2950// --- algo.LineBuf.buf.qFind
2951// 'quick' Access row by row id. No bounds checking.
2952inline char& algo::buf_qFind(algo::LineBuf& parent, u64 t) {
2953 return parent.buf_elems[t];
2954}
2955
2956// --- algo.LineBuf.buf.qLast
2957// Return reference to last element of array. No bounds checking
2958inline char& algo::buf_qLast(algo::LineBuf& parent) {
2959 return buf_qFind(parent, u64(parent.buf_n-1));
2960}
2961
2962// --- algo.LineBuf.buf.rowid_Get
2963// Return row id of specified element
2964inline u64 algo::buf_rowid_Get(algo::LineBuf& parent, char &elem) {
2965 u64 id = &elem - parent.buf_elems;
2966 return u64(id);
2967}
2968
2969// --- algo.LineBuf.buf_curs.Next
2970// proceed to next item
2971inline void algo::LineBuf_buf_curs_Next(LineBuf_buf_curs &curs) {
2972 curs.index++;
2973}
2974
2975// --- algo.LineBuf.buf_curs.Reset
2976inline void algo::LineBuf_buf_curs_Reset(LineBuf_buf_curs &curs, algo::LineBuf &parent) {
2977 curs.elems = parent.buf_elems;
2978 curs.n_elems = parent.buf_n;
2979 curs.index = 0;
2980}
2981
2982// --- algo.LineBuf.buf_curs.ValidQ
2983// cursor points to valid item
2984inline bool algo::LineBuf_buf_curs_ValidQ(LineBuf_buf_curs &curs) {
2985 return curs.index < curs.n_elems;
2986}
2987
2988// --- algo.LineBuf.buf_curs.Access
2989// item access
2990inline char& algo::LineBuf_buf_curs_Access(LineBuf_buf_curs &curs) {
2991 return curs.elems[curs.index];
2992}
2993
2994// --- algo.LineBuf..Init
2995// Set all fields to initial values.
2996inline void algo::LineBuf_Init(algo::LineBuf& parent) {
2997 parent.buf_elems = 0; // (algo.LineBuf.buf)
2998 parent.buf_n = 0; // (algo.LineBuf.buf)
2999 parent.buf_max = 0; // (algo.LineBuf.buf)
3000 parent.implied_eof = bool(false);
3001 parent.eof = bool(false);
3002}
3003
3004inline bool algo::LnumStr10_U64::operator ==(const algo::LnumStr10_U64 &rhs) const {
3005 return algo::LnumStr10_U64_Eq(const_cast<algo::LnumStr10_U64&>(*this),const_cast<algo::LnumStr10_U64&>(rhs));
3006}
3007
3008inline bool algo::LnumStr10_U64::operator !=(const algo::LnumStr10_U64 &rhs) const {
3009 return !algo::LnumStr10_U64_Eq(const_cast<algo::LnumStr10_U64&>(*this),const_cast<algo::LnumStr10_U64&>(rhs));
3010}
3011
3012inline bool algo::LnumStr10_U64::operator ==(const algo::strptr &rhs) const {
3013 return algo::LnumStr10_U64_EqStrptr(const_cast<algo::LnumStr10_U64&>(*this),rhs);
3014}
3015inline algo::LnumStr10_U64::LnumStr10_U64() {
3016 algo::LnumStr10_U64_Init(*this);
3017}
3018
3019
3020// --- algo.LnumStr10_U64.ch.Getary
3021// Access string as array of chars
3022inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr10_U64& parent) {
3023 int len = ch_N(parent);
3024 algo::aryptr<char> ret((char*)parent.ch, len);
3025 ret.elems += 10 - len;
3026 return ret;
3027}
3028
3029// --- algo.LnumStr10_U64.ch.HashStrptr
3030inline u32 algo::LnumStr10_U64_Hash(u32 prev, const algo::strptr &str) {
3031 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3032}
3033
3034// --- algo.LnumStr10_U64.ch.Init
3035inline void algo::ch_Init(algo::LnumStr10_U64 &parent) {
3036 for (int i = 0; i < 10; i++) {
3037 parent.ch[i] = '0';
3038 }
3039}
3040
3041// --- algo.LnumStr10_U64.ch.Max
3042// always return constant 10
3043inline int algo::ch_Max(algo::LnumStr10_U64& parent) {
3044 (void)parent;
3045 return 10;
3046}
3047
3048// --- algo.LnumStr10_U64.ch.N
3049inline int algo::ch_N(const algo::LnumStr10_U64& parent) {
3050 u64 ret;
3051 ret = 0;
3052 while (ret<10 && parent.ch[ret]==u8('0')) {
3053 ret++;
3054 }
3055 ret = 10 - ret;
3056 return int(ret);
3057}
3058
3059// --- algo.LnumStr10_U64.ch.AssignStrptr
3060// Copy from strptr (operator=)
3061inline void algo::LnumStr10_U64::operator =(const algo::strptr &str) {
3062 ch_SetStrptr(*this, str);
3063}
3064
3065// --- algo.LnumStr10_U64.ch.Set
3066// Copy from same type
3067// Copy value from RHS.
3068inline void algo::LnumStr10_U64::operator =(const algo::LnumStr10_U64& parent) {
3069 memcpy(ch, parent.ch, 10);
3070}
3071
3072// --- algo.LnumStr10_U64.ch.Ctor
3073inline algo::LnumStr10_U64::LnumStr10_U64(const algo::LnumStr10_U64 &rhs) {
3074 operator =(rhs);
3075}
3076
3077// --- algo.LnumStr10_U64.ch.CtorStrptr
3078inline algo::LnumStr10_U64::LnumStr10_U64(const algo::strptr &rhs) {
3079 ch_SetStrptr(*this, rhs);
3080}
3081
3082// --- algo.LnumStr10_U64.ch.Cast
3083inline algo::LnumStr10_U64::operator algo::strptr () const {
3084 return ch_Getary(*this);
3085}
3086
3087// --- algo.LnumStr10_U64..Cmp
3088inline i32 algo::LnumStr10_U64_Cmp(algo::LnumStr10_U64& lhs, algo::LnumStr10_U64& rhs) {
3089 i32 retval = 0;
3090 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3091 return retval;
3092}
3093
3094// --- algo.LnumStr10_U64..Init
3095// Set all fields to initial values.
3096inline void algo::LnumStr10_U64_Init(algo::LnumStr10_U64& parent) {
3097 for (int i = 0; i < 10; i++) {
3098 parent.ch[i] = '0';
3099 }
3100}
3101
3102// --- algo.LnumStr10_U64..Eq
3103inline bool algo::LnumStr10_U64_Eq(algo::LnumStr10_U64& lhs, algo::LnumStr10_U64& rhs) {
3104 bool retval = true;
3105 retval = retval
3106 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
3107 &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8);
3108 return retval;
3109}
3110
3111// --- algo.LnumStr10_U64..EqStrptr
3112inline bool algo::LnumStr10_U64_EqStrptr(const algo::LnumStr10_U64& lhs, const algo::strptr& rhs) {
3113 return algo::strptr_Eq(ch_Getary(lhs), rhs);
3114}
3115
3116inline bool algo::LnumStr11_U64::operator ==(const algo::LnumStr11_U64 &rhs) const {
3117 return algo::LnumStr11_U64_Eq(const_cast<algo::LnumStr11_U64&>(*this),const_cast<algo::LnumStr11_U64&>(rhs));
3118}
3119
3120inline bool algo::LnumStr11_U64::operator !=(const algo::LnumStr11_U64 &rhs) const {
3121 return !algo::LnumStr11_U64_Eq(const_cast<algo::LnumStr11_U64&>(*this),const_cast<algo::LnumStr11_U64&>(rhs));
3122}
3123
3124inline bool algo::LnumStr11_U64::operator ==(const algo::strptr &rhs) const {
3125 return algo::LnumStr11_U64_EqStrptr(const_cast<algo::LnumStr11_U64&>(*this),rhs);
3126}
3127inline algo::LnumStr11_U64::LnumStr11_U64() {
3128 algo::LnumStr11_U64_Init(*this);
3129}
3130
3131
3132// --- algo.LnumStr11_U64.ch.Getary
3133// Access string as array of chars
3134inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr11_U64& parent) {
3135 int len = ch_N(parent);
3136 algo::aryptr<char> ret((char*)parent.ch, len);
3137 ret.elems += 11 - len;
3138 return ret;
3139}
3140
3141// --- algo.LnumStr11_U64.ch.HashStrptr
3142inline u32 algo::LnumStr11_U64_Hash(u32 prev, const algo::strptr &str) {
3143 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3144}
3145
3146// --- algo.LnumStr11_U64.ch.Init
3147inline void algo::ch_Init(algo::LnumStr11_U64 &parent) {
3148 for (int i = 0; i < 11; i++) {
3149 parent.ch[i] = '0';
3150 }
3151}
3152
3153// --- algo.LnumStr11_U64.ch.Max
3154// always return constant 11
3155inline int algo::ch_Max(algo::LnumStr11_U64& parent) {
3156 (void)parent;
3157 return 11;
3158}
3159
3160// --- algo.LnumStr11_U64.ch.N
3161inline int algo::ch_N(const algo::LnumStr11_U64& parent) {
3162 u64 ret;
3163 ret = 0;
3164 while (ret<11 && parent.ch[ret]==u8('0')) {
3165 ret++;
3166 }
3167 ret = 11 - ret;
3168 return int(ret);
3169}
3170
3171// --- algo.LnumStr11_U64.ch.AssignStrptr
3172// Copy from strptr (operator=)
3173inline void algo::LnumStr11_U64::operator =(const algo::strptr &str) {
3174 ch_SetStrptr(*this, str);
3175}
3176
3177// --- algo.LnumStr11_U64.ch.Set
3178// Copy from same type
3179// Copy value from RHS.
3180inline void algo::LnumStr11_U64::operator =(const algo::LnumStr11_U64& parent) {
3181 memcpy(ch, parent.ch, 11);
3182}
3183
3184// --- algo.LnumStr11_U64.ch.Ctor
3185inline algo::LnumStr11_U64::LnumStr11_U64(const algo::LnumStr11_U64 &rhs) {
3186 operator =(rhs);
3187}
3188
3189// --- algo.LnumStr11_U64.ch.CtorStrptr
3190inline algo::LnumStr11_U64::LnumStr11_U64(const algo::strptr &rhs) {
3191 ch_SetStrptr(*this, rhs);
3192}
3193
3194// --- algo.LnumStr11_U64.ch.Cast
3195inline algo::LnumStr11_U64::operator algo::strptr () const {
3196 return ch_Getary(*this);
3197}
3198
3199// --- algo.LnumStr11_U64..Cmp
3200inline i32 algo::LnumStr11_U64_Cmp(algo::LnumStr11_U64& lhs, algo::LnumStr11_U64& rhs) {
3201 i32 retval = 0;
3202 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3203 return retval;
3204}
3205
3206// --- algo.LnumStr11_U64..Init
3207// Set all fields to initial values.
3208inline void algo::LnumStr11_U64_Init(algo::LnumStr11_U64& parent) {
3209 for (int i = 0; i < 11; i++) {
3210 parent.ch[i] = '0';
3211 }
3212}
3213
3214// --- algo.LnumStr11_U64..Eq
3215inline bool algo::LnumStr11_U64_Eq(algo::LnumStr11_U64& lhs, algo::LnumStr11_U64& rhs) {
3216 bool retval = true;
3217 retval = retval
3218 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
3219 &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8)
3220 &&*(u8*)(lhs.ch+10) == *(u8*)(rhs.ch+10);
3221 return retval;
3222}
3223
3224// --- algo.LnumStr11_U64..EqStrptr
3225inline bool algo::LnumStr11_U64_EqStrptr(const algo::LnumStr11_U64& lhs, const algo::strptr& rhs) {
3226 return algo::strptr_Eq(ch_Getary(lhs), rhs);
3227}
3228
3229inline bool algo::LnumStr12_U64::operator ==(const algo::LnumStr12_U64 &rhs) const {
3230 return algo::LnumStr12_U64_Eq(const_cast<algo::LnumStr12_U64&>(*this),const_cast<algo::LnumStr12_U64&>(rhs));
3231}
3232
3233inline bool algo::LnumStr12_U64::operator !=(const algo::LnumStr12_U64 &rhs) const {
3234 return !algo::LnumStr12_U64_Eq(const_cast<algo::LnumStr12_U64&>(*this),const_cast<algo::LnumStr12_U64&>(rhs));
3235}
3236
3237inline bool algo::LnumStr12_U64::operator ==(const algo::strptr &rhs) const {
3238 return algo::LnumStr12_U64_EqStrptr(const_cast<algo::LnumStr12_U64&>(*this),rhs);
3239}
3240inline algo::LnumStr12_U64::LnumStr12_U64() {
3241 algo::LnumStr12_U64_Init(*this);
3242}
3243
3244
3245// --- algo.LnumStr12_U64.ch.Getary
3246// Access string as array of chars
3247inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr12_U64& parent) {
3248 int len = ch_N(parent);
3249 algo::aryptr<char> ret((char*)parent.ch, len);
3250 ret.elems += 12 - len;
3251 return ret;
3252}
3253
3254// --- algo.LnumStr12_U64.ch.HashStrptr
3255inline u32 algo::LnumStr12_U64_Hash(u32 prev, const algo::strptr &str) {
3256 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3257}
3258
3259// --- algo.LnumStr12_U64.ch.Init
3260inline void algo::ch_Init(algo::LnumStr12_U64 &parent) {
3261 for (int i = 0; i < 12; i++) {
3262 parent.ch[i] = '0';
3263 }
3264}
3265
3266// --- algo.LnumStr12_U64.ch.Max
3267// always return constant 12
3268inline int algo::ch_Max(algo::LnumStr12_U64& parent) {
3269 (void)parent;
3270 return 12;
3271}
3272
3273// --- algo.LnumStr12_U64.ch.N
3274inline int algo::ch_N(const algo::LnumStr12_U64& parent) {
3275 u64 ret;
3276 ret = 0;
3277 while (ret<12 && parent.ch[ret]==u8('0')) {
3278 ret++;
3279 }
3280 ret = 12 - ret;
3281 return int(ret);
3282}
3283
3284// --- algo.LnumStr12_U64.ch.AssignStrptr
3285// Copy from strptr (operator=)
3286inline void algo::LnumStr12_U64::operator =(const algo::strptr &str) {
3287 ch_SetStrptr(*this, str);
3288}
3289
3290// --- algo.LnumStr12_U64.ch.Set
3291// Copy from same type
3292// Copy value from RHS.
3293inline void algo::LnumStr12_U64::operator =(const algo::LnumStr12_U64& parent) {
3294 memcpy(ch, parent.ch, 12);
3295}
3296
3297// --- algo.LnumStr12_U64.ch.Ctor
3298inline algo::LnumStr12_U64::LnumStr12_U64(const algo::LnumStr12_U64 &rhs) {
3299 operator =(rhs);
3300}
3301
3302// --- algo.LnumStr12_U64.ch.CtorStrptr
3303inline algo::LnumStr12_U64::LnumStr12_U64(const algo::strptr &rhs) {
3304 ch_SetStrptr(*this, rhs);
3305}
3306
3307// --- algo.LnumStr12_U64.ch.Cast
3308inline algo::LnumStr12_U64::operator algo::strptr () const {
3309 return ch_Getary(*this);
3310}
3311
3312// --- algo.LnumStr12_U64..Cmp
3313inline i32 algo::LnumStr12_U64_Cmp(algo::LnumStr12_U64& lhs, algo::LnumStr12_U64& rhs) {
3314 i32 retval = 0;
3315 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3316 return retval;
3317}
3318
3319// --- algo.LnumStr12_U64..Init
3320// Set all fields to initial values.
3321inline void algo::LnumStr12_U64_Init(algo::LnumStr12_U64& parent) {
3322 for (int i = 0; i < 12; i++) {
3323 parent.ch[i] = '0';
3324 }
3325}
3326
3327// --- algo.LnumStr12_U64..Eq
3328inline bool algo::LnumStr12_U64_Eq(algo::LnumStr12_U64& lhs, algo::LnumStr12_U64& rhs) {
3329 bool retval = true;
3330 retval = retval
3331 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
3332 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8);
3333 return retval;
3334}
3335
3336// --- algo.LnumStr12_U64..EqStrptr
3337inline bool algo::LnumStr12_U64_EqStrptr(const algo::LnumStr12_U64& lhs, const algo::strptr& rhs) {
3338 return algo::strptr_Eq(ch_Getary(lhs), rhs);
3339}
3340
3341inline bool algo::LnumStr13_U64_Base36::operator ==(const algo::LnumStr13_U64_Base36 &rhs) const {
3342 return algo::LnumStr13_U64_Base36_Eq(const_cast<algo::LnumStr13_U64_Base36&>(*this),const_cast<algo::LnumStr13_U64_Base36&>(rhs));
3343}
3344
3345inline bool algo::LnumStr13_U64_Base36::operator !=(const algo::LnumStr13_U64_Base36 &rhs) const {
3346 return !algo::LnumStr13_U64_Base36_Eq(const_cast<algo::LnumStr13_U64_Base36&>(*this),const_cast<algo::LnumStr13_U64_Base36&>(rhs));
3347}
3348
3349inline bool algo::LnumStr13_U64_Base36::operator ==(const algo::strptr &rhs) const {
3350 return algo::LnumStr13_U64_Base36_EqStrptr(const_cast<algo::LnumStr13_U64_Base36&>(*this),rhs);
3351}
3352inline algo::LnumStr13_U64_Base36::LnumStr13_U64_Base36() {
3353 algo::LnumStr13_U64_Base36_Init(*this);
3354}
3355
3356
3357// --- algo.LnumStr13_U64_Base36.ch.Getary
3358// Access string as array of chars
3359inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr13_U64_Base36& parent) {
3360 int len = ch_N(parent);
3361 algo::aryptr<char> ret((char*)parent.ch, len);
3362 ret.elems += 13 - len;
3363 return ret;
3364}
3365
3366// --- algo.LnumStr13_U64_Base36.ch.HashStrptr
3367inline u32 algo::LnumStr13_U64_Base36_Hash(u32 prev, const algo::strptr &str) {
3368 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3369}
3370
3371// --- algo.LnumStr13_U64_Base36.ch.Init
3372inline void algo::ch_Init(algo::LnumStr13_U64_Base36 &parent) {
3373 for (int i = 0; i < 13; i++) {
3374 parent.ch[i] = '0';
3375 }
3376}
3377
3378// --- algo.LnumStr13_U64_Base36.ch.Max
3379// always return constant 13
3380inline int algo::ch_Max(algo::LnumStr13_U64_Base36& parent) {
3381 (void)parent;
3382 return 13;
3383}
3384
3385// --- algo.LnumStr13_U64_Base36.ch.N
3386inline int algo::ch_N(const algo::LnumStr13_U64_Base36& parent) {
3387 u64 ret;
3388 ret = 0;
3389 while (ret<13 && parent.ch[ret]==u8('0')) {
3390 ret++;
3391 }
3392 ret = 13 - ret;
3393 return int(ret);
3394}
3395
3396// --- algo.LnumStr13_U64_Base36.ch.AssignStrptr
3397// Copy from strptr (operator=)
3398inline void algo::LnumStr13_U64_Base36::operator =(const algo::strptr &str) {
3399 ch_SetStrptr(*this, str);
3400}
3401
3402// --- algo.LnumStr13_U64_Base36.ch.Set
3403// Copy from same type
3404// Copy value from RHS.
3405inline void algo::LnumStr13_U64_Base36::operator =(const algo::LnumStr13_U64_Base36& parent) {
3406 memcpy(ch, parent.ch, 13);
3407}
3408
3409// --- algo.LnumStr13_U64_Base36.ch.Ctor
3410inline algo::LnumStr13_U64_Base36::LnumStr13_U64_Base36(const algo::LnumStr13_U64_Base36 &rhs) {
3411 operator =(rhs);
3412}
3413
3414// --- algo.LnumStr13_U64_Base36.ch.CtorStrptr
3415inline algo::LnumStr13_U64_Base36::LnumStr13_U64_Base36(const algo::strptr &rhs) {
3416 ch_SetStrptr(*this, rhs);
3417}
3418
3419// --- algo.LnumStr13_U64_Base36.ch.Cast
3420inline algo::LnumStr13_U64_Base36::operator algo::strptr () const {
3421 return ch_Getary(*this);
3422}
3423
3424// --- algo.LnumStr13_U64_Base36..Cmp
3425inline i32 algo::LnumStr13_U64_Base36_Cmp(algo::LnumStr13_U64_Base36& lhs, algo::LnumStr13_U64_Base36& rhs) {
3426 i32 retval = 0;
3427 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3428 return retval;
3429}
3430
3431// --- algo.LnumStr13_U64_Base36..Init
3432// Set all fields to initial values.
3433inline void algo::LnumStr13_U64_Base36_Init(algo::LnumStr13_U64_Base36& parent) {
3434 for (int i = 0; i < 13; i++) {
3435 parent.ch[i] = '0';
3436 }
3437}
3438
3439// --- algo.LnumStr13_U64_Base36..Eq
3440inline bool algo::LnumStr13_U64_Base36_Eq(algo::LnumStr13_U64_Base36& lhs, algo::LnumStr13_U64_Base36& rhs) {
3441 bool retval = true;
3442 retval = retval
3443 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
3444 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
3445 &&*(u8*)(lhs.ch+12) == *(u8*)(rhs.ch+12);
3446 return retval;
3447}
3448
3449// --- algo.LnumStr13_U64_Base36..EqStrptr
3450inline bool algo::LnumStr13_U64_Base36_EqStrptr(const algo::LnumStr13_U64_Base36& lhs, const algo::strptr& rhs) {
3451 return algo::strptr_Eq(ch_Getary(lhs), rhs);
3452}
3453
3454inline bool algo::LnumStr16_U64_Base16::operator ==(const algo::LnumStr16_U64_Base16 &rhs) const {
3455 return algo::LnumStr16_U64_Base16_Eq(const_cast<algo::LnumStr16_U64_Base16&>(*this),const_cast<algo::LnumStr16_U64_Base16&>(rhs));
3456}
3457
3458inline bool algo::LnumStr16_U64_Base16::operator !=(const algo::LnumStr16_U64_Base16 &rhs) const {
3459 return !algo::LnumStr16_U64_Base16_Eq(const_cast<algo::LnumStr16_U64_Base16&>(*this),const_cast<algo::LnumStr16_U64_Base16&>(rhs));
3460}
3461
3462inline bool algo::LnumStr16_U64_Base16::operator ==(const algo::strptr &rhs) const {
3463 return algo::LnumStr16_U64_Base16_EqStrptr(const_cast<algo::LnumStr16_U64_Base16&>(*this),rhs);
3464}
3465inline algo::LnumStr16_U64_Base16::LnumStr16_U64_Base16() {
3466 algo::LnumStr16_U64_Base16_Init(*this);
3467}
3468
3469
3470// --- algo.LnumStr16_U64_Base16.ch.Getary
3471// Access string as array of chars
3472inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr16_U64_Base16& parent) {
3473 int len = ch_N(parent);
3474 algo::aryptr<char> ret((char*)parent.ch, len);
3475 ret.elems += 16 - len;
3476 return ret;
3477}
3478
3479// --- algo.LnumStr16_U64_Base16.ch.HashStrptr
3480inline u32 algo::LnumStr16_U64_Base16_Hash(u32 prev, const algo::strptr &str) {
3481 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3482}
3483
3484// --- algo.LnumStr16_U64_Base16.ch.Init
3485inline void algo::ch_Init(algo::LnumStr16_U64_Base16 &parent) {
3486 for (int i = 0; i < 16; i++) {
3487 parent.ch[i] = '0';
3488 }
3489}
3490
3491// --- algo.LnumStr16_U64_Base16.ch.Max
3492// always return constant 16
3493inline int algo::ch_Max(algo::LnumStr16_U64_Base16& parent) {
3494 (void)parent;
3495 return 16;
3496}
3497
3498// --- algo.LnumStr16_U64_Base16.ch.N
3499inline int algo::ch_N(const algo::LnumStr16_U64_Base16& parent) {
3500 u64 ret;
3501 ret = 0;
3502 while (ret<16 && parent.ch[ret]==u8('0')) {
3503 ret++;
3504 }
3505 ret = 16 - ret;
3506 return int(ret);
3507}
3508
3509// --- algo.LnumStr16_U64_Base16.ch.AssignStrptr
3510// Copy from strptr (operator=)
3511inline void algo::LnumStr16_U64_Base16::operator =(const algo::strptr &str) {
3512 ch_SetStrptr(*this, str);
3513}
3514
3515// --- algo.LnumStr16_U64_Base16.ch.Set
3516// Copy from same type
3517// Copy value from RHS.
3518inline void algo::LnumStr16_U64_Base16::operator =(const algo::LnumStr16_U64_Base16& parent) {
3519 memcpy(ch, parent.ch, 16);
3520}
3521
3522// --- algo.LnumStr16_U64_Base16.ch.Ctor
3523inline algo::LnumStr16_U64_Base16::LnumStr16_U64_Base16(const algo::LnumStr16_U64_Base16 &rhs) {
3524 operator =(rhs);
3525}
3526
3527// --- algo.LnumStr16_U64_Base16.ch.CtorStrptr
3528inline algo::LnumStr16_U64_Base16::LnumStr16_U64_Base16(const algo::strptr &rhs) {
3529 ch_SetStrptr(*this, rhs);
3530}
3531
3532// --- algo.LnumStr16_U64_Base16.ch.Cast
3533inline algo::LnumStr16_U64_Base16::operator algo::strptr () const {
3534 return ch_Getary(*this);
3535}
3536
3537// --- algo.LnumStr16_U64_Base16..Cmp
3538inline i32 algo::LnumStr16_U64_Base16_Cmp(algo::LnumStr16_U64_Base16& lhs, algo::LnumStr16_U64_Base16& rhs) {
3539 i32 retval = 0;
3540 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3541 return retval;
3542}
3543
3544// --- algo.LnumStr16_U64_Base16..Init
3545// Set all fields to initial values.
3546inline void algo::LnumStr16_U64_Base16_Init(algo::LnumStr16_U64_Base16& parent) {
3547 for (int i = 0; i < 16; i++) {
3548 parent.ch[i] = '0';
3549 }
3550}
3551
3552// --- algo.LnumStr16_U64_Base16..Eq
3553inline bool algo::LnumStr16_U64_Base16_Eq(algo::LnumStr16_U64_Base16& lhs, algo::LnumStr16_U64_Base16& rhs) {
3554 bool retval = true;
3555 retval = retval
3556 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
3557 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8);
3558 return retval;
3559}
3560
3561// --- algo.LnumStr16_U64_Base16..EqStrptr
3562inline bool algo::LnumStr16_U64_Base16_EqStrptr(const algo::LnumStr16_U64_Base16& lhs, const algo::strptr& rhs) {
3563 return algo::strptr_Eq(ch_Getary(lhs), rhs);
3564}
3565
3566inline bool algo::LnumStr1_U32::operator ==(const algo::LnumStr1_U32 &rhs) const {
3567 return algo::LnumStr1_U32_Eq(const_cast<algo::LnumStr1_U32&>(*this),const_cast<algo::LnumStr1_U32&>(rhs));
3568}
3569
3570inline bool algo::LnumStr1_U32::operator !=(const algo::LnumStr1_U32 &rhs) const {
3571 return !algo::LnumStr1_U32_Eq(const_cast<algo::LnumStr1_U32&>(*this),const_cast<algo::LnumStr1_U32&>(rhs));
3572}
3573
3574inline bool algo::LnumStr1_U32::operator ==(const algo::strptr &rhs) const {
3575 return algo::LnumStr1_U32_EqStrptr(const_cast<algo::LnumStr1_U32&>(*this),rhs);
3576}
3577inline algo::LnumStr1_U32::LnumStr1_U32() {
3578 algo::LnumStr1_U32_Init(*this);
3579}
3580
3581
3582// --- algo.LnumStr1_U32.ch.Getary
3583// Access string as array of chars
3584inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr1_U32& parent) {
3585 int len = ch_N(parent);
3586 algo::aryptr<char> ret((char*)parent.ch, len);
3587 ret.elems += 1 - len;
3588 return ret;
3589}
3590
3591// --- algo.LnumStr1_U32.ch.HashStrptr
3592inline u32 algo::LnumStr1_U32_Hash(u32 prev, const algo::strptr &str) {
3593 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3594}
3595
3596// --- algo.LnumStr1_U32.ch.Init
3597inline void algo::ch_Init(algo::LnumStr1_U32 &parent) {
3598 for (int i = 0; i < 1; i++) {
3599 parent.ch[i] = '0';
3600 }
3601}
3602
3603// --- algo.LnumStr1_U32.ch.Max
3604// always return constant 1
3605inline int algo::ch_Max(algo::LnumStr1_U32& parent) {
3606 (void)parent;
3607 return 1;
3608}
3609
3610// --- algo.LnumStr1_U32.ch.N
3611inline int algo::ch_N(const algo::LnumStr1_U32& parent) {
3612 u64 ret;
3613 ret = 0;
3614 while (ret<1 && parent.ch[ret]==u8('0')) {
3615 ret++;
3616 }
3617 ret = 1 - ret;
3618 return int(ret);
3619}
3620
3621// --- algo.LnumStr1_U32.ch.AssignStrptr
3622// Copy from strptr (operator=)
3623inline void algo::LnumStr1_U32::operator =(const algo::strptr &str) {
3624 ch_SetStrptr(*this, str);
3625}
3626
3627// --- algo.LnumStr1_U32.ch.Set
3628// Copy from same type
3629// Copy value from RHS.
3630inline void algo::LnumStr1_U32::operator =(const algo::LnumStr1_U32& parent) {
3631 memcpy(ch, parent.ch, 1);
3632}
3633
3634// --- algo.LnumStr1_U32.ch.Ctor
3635inline algo::LnumStr1_U32::LnumStr1_U32(const algo::LnumStr1_U32 &rhs) {
3636 operator =(rhs);
3637}
3638
3639// --- algo.LnumStr1_U32.ch.CtorStrptr
3640inline algo::LnumStr1_U32::LnumStr1_U32(const algo::strptr &rhs) {
3641 ch_SetStrptr(*this, rhs);
3642}
3643
3644// --- algo.LnumStr1_U32.ch.Cast
3645inline algo::LnumStr1_U32::operator algo::strptr () const {
3646 return ch_Getary(*this);
3647}
3648
3649// --- algo.LnumStr1_U32..Cmp
3650inline i32 algo::LnumStr1_U32_Cmp(algo::LnumStr1_U32& lhs, algo::LnumStr1_U32& rhs) {
3651 i32 retval = 0;
3652 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3653 return retval;
3654}
3655
3656// --- algo.LnumStr1_U32..Init
3657// Set all fields to initial values.
3658inline void algo::LnumStr1_U32_Init(algo::LnumStr1_U32& parent) {
3659 for (int i = 0; i < 1; i++) {
3660 parent.ch[i] = '0';
3661 }
3662}
3663
3664// --- algo.LnumStr1_U32..Eq
3665inline bool algo::LnumStr1_U32_Eq(algo::LnumStr1_U32& lhs, algo::LnumStr1_U32& rhs) {
3666 bool retval = true;
3667 retval = retval
3668 &&*(u8*)(lhs.ch+0) == *(u8*)(rhs.ch+0);
3669 return retval;
3670}
3671
3672// --- algo.LnumStr1_U32..EqStrptr
3673inline bool algo::LnumStr1_U32_EqStrptr(const algo::LnumStr1_U32& lhs, const algo::strptr& rhs) {
3674 return algo::strptr_Eq(ch_Getary(lhs), rhs);
3675}
3676
3677inline bool algo::LnumStr20_U64::operator ==(const algo::LnumStr20_U64 &rhs) const {
3678 return algo::LnumStr20_U64_Eq(const_cast<algo::LnumStr20_U64&>(*this),const_cast<algo::LnumStr20_U64&>(rhs));
3679}
3680
3681inline bool algo::LnumStr20_U64::operator !=(const algo::LnumStr20_U64 &rhs) const {
3682 return !algo::LnumStr20_U64_Eq(const_cast<algo::LnumStr20_U64&>(*this),const_cast<algo::LnumStr20_U64&>(rhs));
3683}
3684
3685inline bool algo::LnumStr20_U64::operator ==(const algo::strptr &rhs) const {
3686 return algo::LnumStr20_U64_EqStrptr(const_cast<algo::LnumStr20_U64&>(*this),rhs);
3687}
3688inline algo::LnumStr20_U64::LnumStr20_U64() {
3689 algo::LnumStr20_U64_Init(*this);
3690}
3691
3692
3693// --- algo.LnumStr20_U64.ch.Getary
3694// Access string as array of chars
3695inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr20_U64& parent) {
3696 int len = ch_N(parent);
3697 algo::aryptr<char> ret((char*)parent.ch, len);
3698 ret.elems += 20 - len;
3699 return ret;
3700}
3701
3702// --- algo.LnumStr20_U64.ch.HashStrptr
3703inline u32 algo::LnumStr20_U64_Hash(u32 prev, const algo::strptr &str) {
3704 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3705}
3706
3707// --- algo.LnumStr20_U64.ch.Init
3708inline void algo::ch_Init(algo::LnumStr20_U64 &parent) {
3709 for (int i = 0; i < 20; i++) {
3710 parent.ch[i] = '0';
3711 }
3712}
3713
3714// --- algo.LnumStr20_U64.ch.Max
3715// always return constant 20
3716inline int algo::ch_Max(algo::LnumStr20_U64& parent) {
3717 (void)parent;
3718 return 20;
3719}
3720
3721// --- algo.LnumStr20_U64.ch.N
3722inline int algo::ch_N(const algo::LnumStr20_U64& parent) {
3723 u64 ret;
3724 ret = 0;
3725 while (ret<20 && parent.ch[ret]==u8('0')) {
3726 ret++;
3727 }
3728 ret = 20 - ret;
3729 return int(ret);
3730}
3731
3732// --- algo.LnumStr20_U64.ch.AssignStrptr
3733// Copy from strptr (operator=)
3734inline void algo::LnumStr20_U64::operator =(const algo::strptr &str) {
3735 ch_SetStrptr(*this, str);
3736}
3737
3738// --- algo.LnumStr20_U64.ch.Set
3739// Copy from same type
3740// Copy value from RHS.
3741inline void algo::LnumStr20_U64::operator =(const algo::LnumStr20_U64& parent) {
3742 memcpy(ch, parent.ch, 20);
3743}
3744
3745// --- algo.LnumStr20_U64.ch.Ctor
3746inline algo::LnumStr20_U64::LnumStr20_U64(const algo::LnumStr20_U64 &rhs) {
3747 operator =(rhs);
3748}
3749
3750// --- algo.LnumStr20_U64.ch.CtorStrptr
3751inline algo::LnumStr20_U64::LnumStr20_U64(const algo::strptr &rhs) {
3752 ch_SetStrptr(*this, rhs);
3753}
3754
3755// --- algo.LnumStr20_U64.ch.Cast
3756inline algo::LnumStr20_U64::operator algo::strptr () const {
3757 return ch_Getary(*this);
3758}
3759
3760// --- algo.LnumStr20_U64..Cmp
3761inline i32 algo::LnumStr20_U64_Cmp(algo::LnumStr20_U64& lhs, algo::LnumStr20_U64& rhs) {
3762 i32 retval = 0;
3763 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3764 return retval;
3765}
3766
3767// --- algo.LnumStr20_U64..Init
3768// Set all fields to initial values.
3769inline void algo::LnumStr20_U64_Init(algo::LnumStr20_U64& parent) {
3770 for (int i = 0; i < 20; i++) {
3771 parent.ch[i] = '0';
3772 }
3773}
3774
3775// --- algo.LnumStr20_U64..Eq
3776inline bool algo::LnumStr20_U64_Eq(algo::LnumStr20_U64& lhs, algo::LnumStr20_U64& rhs) {
3777 bool retval = true;
3778 retval = retval
3779 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
3780 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
3781 &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
3782 return retval;
3783}
3784
3785// --- algo.LnumStr20_U64..EqStrptr
3786inline bool algo::LnumStr20_U64_EqStrptr(const algo::LnumStr20_U64& lhs, const algo::strptr& rhs) {
3787 return algo::strptr_Eq(ch_Getary(lhs), rhs);
3788}
3789
3790inline bool algo::LnumStr22_U64::operator ==(const algo::LnumStr22_U64 &rhs) const {
3791 return algo::LnumStr22_U64_Eq(const_cast<algo::LnumStr22_U64&>(*this),const_cast<algo::LnumStr22_U64&>(rhs));
3792}
3793
3794inline bool algo::LnumStr22_U64::operator !=(const algo::LnumStr22_U64 &rhs) const {
3795 return !algo::LnumStr22_U64_Eq(const_cast<algo::LnumStr22_U64&>(*this),const_cast<algo::LnumStr22_U64&>(rhs));
3796}
3797
3798inline bool algo::LnumStr22_U64::operator ==(const algo::strptr &rhs) const {
3799 return algo::LnumStr22_U64_EqStrptr(const_cast<algo::LnumStr22_U64&>(*this),rhs);
3800}
3801inline algo::LnumStr22_U64::LnumStr22_U64() {
3802 algo::LnumStr22_U64_Init(*this);
3803}
3804
3805
3806// --- algo.LnumStr22_U64.ch.Getary
3807// Access string as array of chars
3808inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr22_U64& parent) {
3809 int len = ch_N(parent);
3810 algo::aryptr<char> ret((char*)parent.ch, len);
3811 ret.elems += 22 - len;
3812 return ret;
3813}
3814
3815// --- algo.LnumStr22_U64.ch.HashStrptr
3816inline u32 algo::LnumStr22_U64_Hash(u32 prev, const algo::strptr &str) {
3817 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3818}
3819
3820// --- algo.LnumStr22_U64.ch.Init
3821inline void algo::ch_Init(algo::LnumStr22_U64 &parent) {
3822 for (int i = 0; i < 22; i++) {
3823 parent.ch[i] = '0';
3824 }
3825}
3826
3827// --- algo.LnumStr22_U64.ch.Max
3828// always return constant 22
3829inline int algo::ch_Max(algo::LnumStr22_U64& parent) {
3830 (void)parent;
3831 return 22;
3832}
3833
3834// --- algo.LnumStr22_U64.ch.N
3835inline int algo::ch_N(const algo::LnumStr22_U64& parent) {
3836 u64 ret;
3837 ret = 0;
3838 while (ret<22 && parent.ch[ret]==u8('0')) {
3839 ret++;
3840 }
3841 ret = 22 - ret;
3842 return int(ret);
3843}
3844
3845// --- algo.LnumStr22_U64.ch.AssignStrptr
3846// Copy from strptr (operator=)
3847inline void algo::LnumStr22_U64::operator =(const algo::strptr &str) {
3848 ch_SetStrptr(*this, str);
3849}
3850
3851// --- algo.LnumStr22_U64.ch.Set
3852// Copy from same type
3853// Copy value from RHS.
3854inline void algo::LnumStr22_U64::operator =(const algo::LnumStr22_U64& parent) {
3855 memcpy(ch, parent.ch, 22);
3856}
3857
3858// --- algo.LnumStr22_U64.ch.Ctor
3859inline algo::LnumStr22_U64::LnumStr22_U64(const algo::LnumStr22_U64 &rhs) {
3860 operator =(rhs);
3861}
3862
3863// --- algo.LnumStr22_U64.ch.CtorStrptr
3864inline algo::LnumStr22_U64::LnumStr22_U64(const algo::strptr &rhs) {
3865 ch_SetStrptr(*this, rhs);
3866}
3867
3868// --- algo.LnumStr22_U64.ch.Cast
3869inline algo::LnumStr22_U64::operator algo::strptr () const {
3870 return ch_Getary(*this);
3871}
3872
3873// --- algo.LnumStr22_U64..Cmp
3874inline i32 algo::LnumStr22_U64_Cmp(algo::LnumStr22_U64& lhs, algo::LnumStr22_U64& rhs) {
3875 i32 retval = 0;
3876 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3877 return retval;
3878}
3879
3880// --- algo.LnumStr22_U64..Init
3881// Set all fields to initial values.
3882inline void algo::LnumStr22_U64_Init(algo::LnumStr22_U64& parent) {
3883 for (int i = 0; i < 22; i++) {
3884 parent.ch[i] = '0';
3885 }
3886}
3887
3888// --- algo.LnumStr22_U64..Eq
3889inline bool algo::LnumStr22_U64_Eq(algo::LnumStr22_U64& lhs, algo::LnumStr22_U64& rhs) {
3890 bool retval = true;
3891 retval = retval
3892 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
3893 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
3894 &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16)
3895 &&*(u16*)(lhs.ch+20) == *(u16*)(rhs.ch+20);
3896 return retval;
3897}
3898
3899// --- algo.LnumStr22_U64..EqStrptr
3900inline bool algo::LnumStr22_U64_EqStrptr(const algo::LnumStr22_U64& lhs, const algo::strptr& rhs) {
3901 return algo::strptr_Eq(ch_Getary(lhs), rhs);
3902}
3903
3904inline bool algo::LnumStr2_U32::operator ==(const algo::LnumStr2_U32 &rhs) const {
3905 return algo::LnumStr2_U32_Eq(const_cast<algo::LnumStr2_U32&>(*this),const_cast<algo::LnumStr2_U32&>(rhs));
3906}
3907
3908inline bool algo::LnumStr2_U32::operator !=(const algo::LnumStr2_U32 &rhs) const {
3909 return !algo::LnumStr2_U32_Eq(const_cast<algo::LnumStr2_U32&>(*this),const_cast<algo::LnumStr2_U32&>(rhs));
3910}
3911
3912inline bool algo::LnumStr2_U32::operator ==(const algo::strptr &rhs) const {
3913 return algo::LnumStr2_U32_EqStrptr(const_cast<algo::LnumStr2_U32&>(*this),rhs);
3914}
3915inline algo::LnumStr2_U32::LnumStr2_U32() {
3916 algo::LnumStr2_U32_Init(*this);
3917}
3918
3919
3920// --- algo.LnumStr2_U32.ch.Getary
3921// Access string as array of chars
3922inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr2_U32& parent) {
3923 int len = ch_N(parent);
3924 algo::aryptr<char> ret((char*)parent.ch, len);
3925 ret.elems += 2 - len;
3926 return ret;
3927}
3928
3929// --- algo.LnumStr2_U32.ch.HashStrptr
3930inline u32 algo::LnumStr2_U32_Hash(u32 prev, const algo::strptr &str) {
3931 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
3932}
3933
3934// --- algo.LnumStr2_U32.ch.Init
3935inline void algo::ch_Init(algo::LnumStr2_U32 &parent) {
3936 for (int i = 0; i < 2; i++) {
3937 parent.ch[i] = '0';
3938 }
3939}
3940
3941// --- algo.LnumStr2_U32.ch.Max
3942// always return constant 2
3943inline int algo::ch_Max(algo::LnumStr2_U32& parent) {
3944 (void)parent;
3945 return 2;
3946}
3947
3948// --- algo.LnumStr2_U32.ch.N
3949inline int algo::ch_N(const algo::LnumStr2_U32& parent) {
3950 u64 ret;
3951 ret = 0;
3952 while (ret<2 && parent.ch[ret]==u8('0')) {
3953 ret++;
3954 }
3955 ret = 2 - ret;
3956 return int(ret);
3957}
3958
3959// --- algo.LnumStr2_U32.ch.AssignStrptr
3960// Copy from strptr (operator=)
3961inline void algo::LnumStr2_U32::operator =(const algo::strptr &str) {
3962 ch_SetStrptr(*this, str);
3963}
3964
3965// --- algo.LnumStr2_U32.ch.Set
3966// Copy from same type
3967// Copy value from RHS.
3968inline void algo::LnumStr2_U32::operator =(const algo::LnumStr2_U32& parent) {
3969 memcpy(ch, parent.ch, 2);
3970}
3971
3972// --- algo.LnumStr2_U32.ch.Ctor
3973inline algo::LnumStr2_U32::LnumStr2_U32(const algo::LnumStr2_U32 &rhs) {
3974 operator =(rhs);
3975}
3976
3977// --- algo.LnumStr2_U32.ch.CtorStrptr
3978inline algo::LnumStr2_U32::LnumStr2_U32(const algo::strptr &rhs) {
3979 ch_SetStrptr(*this, rhs);
3980}
3981
3982// --- algo.LnumStr2_U32.ch.Cast
3983inline algo::LnumStr2_U32::operator algo::strptr () const {
3984 return ch_Getary(*this);
3985}
3986
3987// --- algo.LnumStr2_U32..Cmp
3988inline i32 algo::LnumStr2_U32_Cmp(algo::LnumStr2_U32& lhs, algo::LnumStr2_U32& rhs) {
3989 i32 retval = 0;
3990 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
3991 return retval;
3992}
3993
3994// --- algo.LnumStr2_U32..Init
3995// Set all fields to initial values.
3996inline void algo::LnumStr2_U32_Init(algo::LnumStr2_U32& parent) {
3997 for (int i = 0; i < 2; i++) {
3998 parent.ch[i] = '0';
3999 }
4000}
4001
4002// --- algo.LnumStr2_U32..Eq
4003inline bool algo::LnumStr2_U32_Eq(algo::LnumStr2_U32& lhs, algo::LnumStr2_U32& rhs) {
4004 bool retval = true;
4005 retval = retval
4006 &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0);
4007 return retval;
4008}
4009
4010// --- algo.LnumStr2_U32..EqStrptr
4011inline bool algo::LnumStr2_U32_EqStrptr(const algo::LnumStr2_U32& lhs, const algo::strptr& rhs) {
4012 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4013}
4014
4015inline bool algo::LnumStr3_U32::operator ==(const algo::LnumStr3_U32 &rhs) const {
4016 return algo::LnumStr3_U32_Eq(const_cast<algo::LnumStr3_U32&>(*this),const_cast<algo::LnumStr3_U32&>(rhs));
4017}
4018
4019inline bool algo::LnumStr3_U32::operator !=(const algo::LnumStr3_U32 &rhs) const {
4020 return !algo::LnumStr3_U32_Eq(const_cast<algo::LnumStr3_U32&>(*this),const_cast<algo::LnumStr3_U32&>(rhs));
4021}
4022
4023inline bool algo::LnumStr3_U32::operator ==(const algo::strptr &rhs) const {
4024 return algo::LnumStr3_U32_EqStrptr(const_cast<algo::LnumStr3_U32&>(*this),rhs);
4025}
4026inline algo::LnumStr3_U32::LnumStr3_U32() {
4027 algo::LnumStr3_U32_Init(*this);
4028}
4029
4030
4031// --- algo.LnumStr3_U32.ch.Getary
4032// Access string as array of chars
4033inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr3_U32& parent) {
4034 int len = ch_N(parent);
4035 algo::aryptr<char> ret((char*)parent.ch, len);
4036 ret.elems += 3 - len;
4037 return ret;
4038}
4039
4040// --- algo.LnumStr3_U32.ch.HashStrptr
4041inline u32 algo::LnumStr3_U32_Hash(u32 prev, const algo::strptr &str) {
4042 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4043}
4044
4045// --- algo.LnumStr3_U32.ch.Init
4046inline void algo::ch_Init(algo::LnumStr3_U32 &parent) {
4047 for (int i = 0; i < 3; i++) {
4048 parent.ch[i] = '0';
4049 }
4050}
4051
4052// --- algo.LnumStr3_U32.ch.Max
4053// always return constant 3
4054inline int algo::ch_Max(algo::LnumStr3_U32& parent) {
4055 (void)parent;
4056 return 3;
4057}
4058
4059// --- algo.LnumStr3_U32.ch.N
4060inline int algo::ch_N(const algo::LnumStr3_U32& parent) {
4061 u64 ret;
4062 ret = 0;
4063 while (ret<3 && parent.ch[ret]==u8('0')) {
4064 ret++;
4065 }
4066 ret = 3 - ret;
4067 return int(ret);
4068}
4069
4070// --- algo.LnumStr3_U32.ch.AssignStrptr
4071// Copy from strptr (operator=)
4072inline void algo::LnumStr3_U32::operator =(const algo::strptr &str) {
4073 ch_SetStrptr(*this, str);
4074}
4075
4076// --- algo.LnumStr3_U32.ch.Set
4077// Copy from same type
4078// Copy value from RHS.
4079inline void algo::LnumStr3_U32::operator =(const algo::LnumStr3_U32& parent) {
4080 memcpy(ch, parent.ch, 3);
4081}
4082
4083// --- algo.LnumStr3_U32.ch.Ctor
4084inline algo::LnumStr3_U32::LnumStr3_U32(const algo::LnumStr3_U32 &rhs) {
4085 operator =(rhs);
4086}
4087
4088// --- algo.LnumStr3_U32.ch.CtorStrptr
4089inline algo::LnumStr3_U32::LnumStr3_U32(const algo::strptr &rhs) {
4090 ch_SetStrptr(*this, rhs);
4091}
4092
4093// --- algo.LnumStr3_U32.ch.Cast
4094inline algo::LnumStr3_U32::operator algo::strptr () const {
4095 return ch_Getary(*this);
4096}
4097
4098// --- algo.LnumStr3_U32..Cmp
4099inline i32 algo::LnumStr3_U32_Cmp(algo::LnumStr3_U32& lhs, algo::LnumStr3_U32& rhs) {
4100 i32 retval = 0;
4101 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4102 return retval;
4103}
4104
4105// --- algo.LnumStr3_U32..Init
4106// Set all fields to initial values.
4107inline void algo::LnumStr3_U32_Init(algo::LnumStr3_U32& parent) {
4108 for (int i = 0; i < 3; i++) {
4109 parent.ch[i] = '0';
4110 }
4111}
4112
4113// --- algo.LnumStr3_U32..Eq
4114inline bool algo::LnumStr3_U32_Eq(algo::LnumStr3_U32& lhs, algo::LnumStr3_U32& rhs) {
4115 bool retval = true;
4116 retval = retval
4117 &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
4118 &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
4119 return retval;
4120}
4121
4122// --- algo.LnumStr3_U32..EqStrptr
4123inline bool algo::LnumStr3_U32_EqStrptr(const algo::LnumStr3_U32& lhs, const algo::strptr& rhs) {
4124 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4125}
4126
4127inline bool algo::LnumStr4_U32::operator ==(const algo::LnumStr4_U32 &rhs) const {
4128 return algo::LnumStr4_U32_Eq(const_cast<algo::LnumStr4_U32&>(*this),const_cast<algo::LnumStr4_U32&>(rhs));
4129}
4130
4131inline bool algo::LnumStr4_U32::operator !=(const algo::LnumStr4_U32 &rhs) const {
4132 return !algo::LnumStr4_U32_Eq(const_cast<algo::LnumStr4_U32&>(*this),const_cast<algo::LnumStr4_U32&>(rhs));
4133}
4134
4135inline bool algo::LnumStr4_U32::operator ==(const algo::strptr &rhs) const {
4136 return algo::LnumStr4_U32_EqStrptr(const_cast<algo::LnumStr4_U32&>(*this),rhs);
4137}
4138inline algo::LnumStr4_U32::LnumStr4_U32() {
4139 algo::LnumStr4_U32_Init(*this);
4140}
4141
4142
4143// --- algo.LnumStr4_U32.ch.Getary
4144// Access string as array of chars
4145inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr4_U32& parent) {
4146 int len = ch_N(parent);
4147 algo::aryptr<char> ret((char*)parent.ch, len);
4148 ret.elems += 4 - len;
4149 return ret;
4150}
4151
4152// --- algo.LnumStr4_U32.ch.HashStrptr
4153inline u32 algo::LnumStr4_U32_Hash(u32 prev, const algo::strptr &str) {
4154 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4155}
4156
4157// --- algo.LnumStr4_U32.ch.Init
4158inline void algo::ch_Init(algo::LnumStr4_U32 &parent) {
4159 for (int i = 0; i < 4; i++) {
4160 parent.ch[i] = '0';
4161 }
4162}
4163
4164// --- algo.LnumStr4_U32.ch.Max
4165// always return constant 4
4166inline int algo::ch_Max(algo::LnumStr4_U32& parent) {
4167 (void)parent;
4168 return 4;
4169}
4170
4171// --- algo.LnumStr4_U32.ch.N
4172inline int algo::ch_N(const algo::LnumStr4_U32& parent) {
4173 u64 ret;
4174 ret = 0;
4175 while (ret<4 && parent.ch[ret]==u8('0')) {
4176 ret++;
4177 }
4178 ret = 4 - ret;
4179 return int(ret);
4180}
4181
4182// --- algo.LnumStr4_U32.ch.AssignStrptr
4183// Copy from strptr (operator=)
4184inline void algo::LnumStr4_U32::operator =(const algo::strptr &str) {
4185 ch_SetStrptr(*this, str);
4186}
4187
4188// --- algo.LnumStr4_U32.ch.Set
4189// Copy from same type
4190// Copy value from RHS.
4191inline void algo::LnumStr4_U32::operator =(const algo::LnumStr4_U32& parent) {
4192 memcpy(ch, parent.ch, 4);
4193}
4194
4195// --- algo.LnumStr4_U32.ch.Ctor
4196inline algo::LnumStr4_U32::LnumStr4_U32(const algo::LnumStr4_U32 &rhs) {
4197 operator =(rhs);
4198}
4199
4200// --- algo.LnumStr4_U32.ch.CtorStrptr
4201inline algo::LnumStr4_U32::LnumStr4_U32(const algo::strptr &rhs) {
4202 ch_SetStrptr(*this, rhs);
4203}
4204
4205// --- algo.LnumStr4_U32.ch.Cast
4206inline algo::LnumStr4_U32::operator algo::strptr () const {
4207 return ch_Getary(*this);
4208}
4209
4210// --- algo.LnumStr4_U32..Cmp
4211inline i32 algo::LnumStr4_U32_Cmp(algo::LnumStr4_U32& lhs, algo::LnumStr4_U32& rhs) {
4212 i32 retval = 0;
4213 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4214 return retval;
4215}
4216
4217// --- algo.LnumStr4_U32..Init
4218// Set all fields to initial values.
4219inline void algo::LnumStr4_U32_Init(algo::LnumStr4_U32& parent) {
4220 for (int i = 0; i < 4; i++) {
4221 parent.ch[i] = '0';
4222 }
4223}
4224
4225// --- algo.LnumStr4_U32..Eq
4226inline bool algo::LnumStr4_U32_Eq(algo::LnumStr4_U32& lhs, algo::LnumStr4_U32& rhs) {
4227 bool retval = true;
4228 retval = retval
4229 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0);
4230 return retval;
4231}
4232
4233// --- algo.LnumStr4_U32..EqStrptr
4234inline bool algo::LnumStr4_U32_EqStrptr(const algo::LnumStr4_U32& lhs, const algo::strptr& rhs) {
4235 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4236}
4237
4238inline bool algo::LnumStr5_U32::operator ==(const algo::LnumStr5_U32 &rhs) const {
4239 return algo::LnumStr5_U32_Eq(const_cast<algo::LnumStr5_U32&>(*this),const_cast<algo::LnumStr5_U32&>(rhs));
4240}
4241
4242inline bool algo::LnumStr5_U32::operator !=(const algo::LnumStr5_U32 &rhs) const {
4243 return !algo::LnumStr5_U32_Eq(const_cast<algo::LnumStr5_U32&>(*this),const_cast<algo::LnumStr5_U32&>(rhs));
4244}
4245
4246inline bool algo::LnumStr5_U32::operator ==(const algo::strptr &rhs) const {
4247 return algo::LnumStr5_U32_EqStrptr(const_cast<algo::LnumStr5_U32&>(*this),rhs);
4248}
4249inline algo::LnumStr5_U32::LnumStr5_U32() {
4250 algo::LnumStr5_U32_Init(*this);
4251}
4252
4253
4254// --- algo.LnumStr5_U32.ch.Getary
4255// Access string as array of chars
4256inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr5_U32& parent) {
4257 int len = ch_N(parent);
4258 algo::aryptr<char> ret((char*)parent.ch, len);
4259 ret.elems += 5 - len;
4260 return ret;
4261}
4262
4263// --- algo.LnumStr5_U32.ch.HashStrptr
4264inline u32 algo::LnumStr5_U32_Hash(u32 prev, const algo::strptr &str) {
4265 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4266}
4267
4268// --- algo.LnumStr5_U32.ch.Init
4269inline void algo::ch_Init(algo::LnumStr5_U32 &parent) {
4270 for (int i = 0; i < 5; i++) {
4271 parent.ch[i] = '0';
4272 }
4273}
4274
4275// --- algo.LnumStr5_U32.ch.Max
4276// always return constant 5
4277inline int algo::ch_Max(algo::LnumStr5_U32& parent) {
4278 (void)parent;
4279 return 5;
4280}
4281
4282// --- algo.LnumStr5_U32.ch.N
4283inline int algo::ch_N(const algo::LnumStr5_U32& parent) {
4284 u64 ret;
4285 ret = 0;
4286 while (ret<5 && parent.ch[ret]==u8('0')) {
4287 ret++;
4288 }
4289 ret = 5 - ret;
4290 return int(ret);
4291}
4292
4293// --- algo.LnumStr5_U32.ch.AssignStrptr
4294// Copy from strptr (operator=)
4295inline void algo::LnumStr5_U32::operator =(const algo::strptr &str) {
4296 ch_SetStrptr(*this, str);
4297}
4298
4299// --- algo.LnumStr5_U32.ch.Set
4300// Copy from same type
4301// Copy value from RHS.
4302inline void algo::LnumStr5_U32::operator =(const algo::LnumStr5_U32& parent) {
4303 memcpy(ch, parent.ch, 5);
4304}
4305
4306// --- algo.LnumStr5_U32.ch.Ctor
4307inline algo::LnumStr5_U32::LnumStr5_U32(const algo::LnumStr5_U32 &rhs) {
4308 operator =(rhs);
4309}
4310
4311// --- algo.LnumStr5_U32.ch.CtorStrptr
4312inline algo::LnumStr5_U32::LnumStr5_U32(const algo::strptr &rhs) {
4313 ch_SetStrptr(*this, rhs);
4314}
4315
4316// --- algo.LnumStr5_U32.ch.Cast
4317inline algo::LnumStr5_U32::operator algo::strptr () const {
4318 return ch_Getary(*this);
4319}
4320
4321// --- algo.LnumStr5_U32..Cmp
4322inline i32 algo::LnumStr5_U32_Cmp(algo::LnumStr5_U32& lhs, algo::LnumStr5_U32& rhs) {
4323 i32 retval = 0;
4324 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4325 return retval;
4326}
4327
4328// --- algo.LnumStr5_U32..Init
4329// Set all fields to initial values.
4330inline void algo::LnumStr5_U32_Init(algo::LnumStr5_U32& parent) {
4331 for (int i = 0; i < 5; i++) {
4332 parent.ch[i] = '0';
4333 }
4334}
4335
4336// --- algo.LnumStr5_U32..Eq
4337inline bool algo::LnumStr5_U32_Eq(algo::LnumStr5_U32& lhs, algo::LnumStr5_U32& rhs) {
4338 bool retval = true;
4339 retval = retval
4340 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
4341 &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
4342 return retval;
4343}
4344
4345// --- algo.LnumStr5_U32..EqStrptr
4346inline bool algo::LnumStr5_U32_EqStrptr(const algo::LnumStr5_U32& lhs, const algo::strptr& rhs) {
4347 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4348}
4349
4350inline bool algo::LnumStr5_U32_Base36::operator ==(const algo::LnumStr5_U32_Base36 &rhs) const {
4351 return algo::LnumStr5_U32_Base36_Eq(const_cast<algo::LnumStr5_U32_Base36&>(*this),const_cast<algo::LnumStr5_U32_Base36&>(rhs));
4352}
4353
4354inline bool algo::LnumStr5_U32_Base36::operator !=(const algo::LnumStr5_U32_Base36 &rhs) const {
4355 return !algo::LnumStr5_U32_Base36_Eq(const_cast<algo::LnumStr5_U32_Base36&>(*this),const_cast<algo::LnumStr5_U32_Base36&>(rhs));
4356}
4357
4358inline bool algo::LnumStr5_U32_Base36::operator ==(const algo::strptr &rhs) const {
4359 return algo::LnumStr5_U32_Base36_EqStrptr(const_cast<algo::LnumStr5_U32_Base36&>(*this),rhs);
4360}
4361inline algo::LnumStr5_U32_Base36::LnumStr5_U32_Base36() {
4362 algo::LnumStr5_U32_Base36_Init(*this);
4363}
4364
4365
4366// --- algo.LnumStr5_U32_Base36.ch.Getary
4367// Access string as array of chars
4368inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr5_U32_Base36& parent) {
4369 int len = ch_N(parent);
4370 algo::aryptr<char> ret((char*)parent.ch, len);
4371 ret.elems += 5 - len;
4372 return ret;
4373}
4374
4375// --- algo.LnumStr5_U32_Base36.ch.HashStrptr
4376inline u32 algo::LnumStr5_U32_Base36_Hash(u32 prev, const algo::strptr &str) {
4377 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4378}
4379
4380// --- algo.LnumStr5_U32_Base36.ch.Init
4381inline void algo::ch_Init(algo::LnumStr5_U32_Base36 &parent) {
4382 for (int i = 0; i < 5; i++) {
4383 parent.ch[i] = '0';
4384 }
4385}
4386
4387// --- algo.LnumStr5_U32_Base36.ch.Max
4388// always return constant 5
4389inline int algo::ch_Max(algo::LnumStr5_U32_Base36& parent) {
4390 (void)parent;
4391 return 5;
4392}
4393
4394// --- algo.LnumStr5_U32_Base36.ch.N
4395inline int algo::ch_N(const algo::LnumStr5_U32_Base36& parent) {
4396 u64 ret;
4397 ret = 0;
4398 while (ret<5 && parent.ch[ret]==u8('0')) {
4399 ret++;
4400 }
4401 ret = 5 - ret;
4402 return int(ret);
4403}
4404
4405// --- algo.LnumStr5_U32_Base36.ch.AssignStrptr
4406// Copy from strptr (operator=)
4407inline void algo::LnumStr5_U32_Base36::operator =(const algo::strptr &str) {
4408 ch_SetStrptr(*this, str);
4409}
4410
4411// --- algo.LnumStr5_U32_Base36.ch.Set
4412// Copy from same type
4413// Copy value from RHS.
4414inline void algo::LnumStr5_U32_Base36::operator =(const algo::LnumStr5_U32_Base36& parent) {
4415 memcpy(ch, parent.ch, 5);
4416}
4417
4418// --- algo.LnumStr5_U32_Base36.ch.Ctor
4419inline algo::LnumStr5_U32_Base36::LnumStr5_U32_Base36(const algo::LnumStr5_U32_Base36 &rhs) {
4420 operator =(rhs);
4421}
4422
4423// --- algo.LnumStr5_U32_Base36.ch.CtorStrptr
4424inline algo::LnumStr5_U32_Base36::LnumStr5_U32_Base36(const algo::strptr &rhs) {
4425 ch_SetStrptr(*this, rhs);
4426}
4427
4428// --- algo.LnumStr5_U32_Base36.ch.Cast
4429inline algo::LnumStr5_U32_Base36::operator algo::strptr () const {
4430 return ch_Getary(*this);
4431}
4432
4433// --- algo.LnumStr5_U32_Base36..Cmp
4434inline i32 algo::LnumStr5_U32_Base36_Cmp(algo::LnumStr5_U32_Base36& lhs, algo::LnumStr5_U32_Base36& rhs) {
4435 i32 retval = 0;
4436 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4437 return retval;
4438}
4439
4440// --- algo.LnumStr5_U32_Base36..Init
4441// Set all fields to initial values.
4442inline void algo::LnumStr5_U32_Base36_Init(algo::LnumStr5_U32_Base36& parent) {
4443 for (int i = 0; i < 5; i++) {
4444 parent.ch[i] = '0';
4445 }
4446}
4447
4448// --- algo.LnumStr5_U32_Base36..Eq
4449inline bool algo::LnumStr5_U32_Base36_Eq(algo::LnumStr5_U32_Base36& lhs, algo::LnumStr5_U32_Base36& rhs) {
4450 bool retval = true;
4451 retval = retval
4452 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
4453 &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
4454 return retval;
4455}
4456
4457// --- algo.LnumStr5_U32_Base36..EqStrptr
4458inline bool algo::LnumStr5_U32_Base36_EqStrptr(const algo::LnumStr5_U32_Base36& lhs, const algo::strptr& rhs) {
4459 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4460}
4461
4462inline bool algo::LnumStr6_U32::operator ==(const algo::LnumStr6_U32 &rhs) const {
4463 return algo::LnumStr6_U32_Eq(const_cast<algo::LnumStr6_U32&>(*this),const_cast<algo::LnumStr6_U32&>(rhs));
4464}
4465
4466inline bool algo::LnumStr6_U32::operator !=(const algo::LnumStr6_U32 &rhs) const {
4467 return !algo::LnumStr6_U32_Eq(const_cast<algo::LnumStr6_U32&>(*this),const_cast<algo::LnumStr6_U32&>(rhs));
4468}
4469
4470inline bool algo::LnumStr6_U32::operator ==(const algo::strptr &rhs) const {
4471 return algo::LnumStr6_U32_EqStrptr(const_cast<algo::LnumStr6_U32&>(*this),rhs);
4472}
4473inline algo::LnumStr6_U32::LnumStr6_U32() {
4474 algo::LnumStr6_U32_Init(*this);
4475}
4476
4477
4478// --- algo.LnumStr6_U32.ch.Getary
4479// Access string as array of chars
4480inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr6_U32& parent) {
4481 int len = ch_N(parent);
4482 algo::aryptr<char> ret((char*)parent.ch, len);
4483 ret.elems += 6 - len;
4484 return ret;
4485}
4486
4487// --- algo.LnumStr6_U32.ch.HashStrptr
4488inline u32 algo::LnumStr6_U32_Hash(u32 prev, const algo::strptr &str) {
4489 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4490}
4491
4492// --- algo.LnumStr6_U32.ch.Init
4493inline void algo::ch_Init(algo::LnumStr6_U32 &parent) {
4494 for (int i = 0; i < 6; i++) {
4495 parent.ch[i] = '0';
4496 }
4497}
4498
4499// --- algo.LnumStr6_U32.ch.Max
4500// always return constant 6
4501inline int algo::ch_Max(algo::LnumStr6_U32& parent) {
4502 (void)parent;
4503 return 6;
4504}
4505
4506// --- algo.LnumStr6_U32.ch.N
4507inline int algo::ch_N(const algo::LnumStr6_U32& parent) {
4508 u64 ret;
4509 ret = 0;
4510 while (ret<6 && parent.ch[ret]==u8('0')) {
4511 ret++;
4512 }
4513 ret = 6 - ret;
4514 return int(ret);
4515}
4516
4517// --- algo.LnumStr6_U32.ch.AssignStrptr
4518// Copy from strptr (operator=)
4519inline void algo::LnumStr6_U32::operator =(const algo::strptr &str) {
4520 ch_SetStrptr(*this, str);
4521}
4522
4523// --- algo.LnumStr6_U32.ch.Set
4524// Copy from same type
4525// Copy value from RHS.
4526inline void algo::LnumStr6_U32::operator =(const algo::LnumStr6_U32& parent) {
4527 memcpy(ch, parent.ch, 6);
4528}
4529
4530// --- algo.LnumStr6_U32.ch.Ctor
4531inline algo::LnumStr6_U32::LnumStr6_U32(const algo::LnumStr6_U32 &rhs) {
4532 operator =(rhs);
4533}
4534
4535// --- algo.LnumStr6_U32.ch.CtorStrptr
4536inline algo::LnumStr6_U32::LnumStr6_U32(const algo::strptr &rhs) {
4537 ch_SetStrptr(*this, rhs);
4538}
4539
4540// --- algo.LnumStr6_U32.ch.Cast
4541inline algo::LnumStr6_U32::operator algo::strptr () const {
4542 return ch_Getary(*this);
4543}
4544
4545// --- algo.LnumStr6_U32..Cmp
4546inline i32 algo::LnumStr6_U32_Cmp(algo::LnumStr6_U32& lhs, algo::LnumStr6_U32& rhs) {
4547 i32 retval = 0;
4548 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4549 return retval;
4550}
4551
4552// --- algo.LnumStr6_U32..Init
4553// Set all fields to initial values.
4554inline void algo::LnumStr6_U32_Init(algo::LnumStr6_U32& parent) {
4555 for (int i = 0; i < 6; i++) {
4556 parent.ch[i] = '0';
4557 }
4558}
4559
4560// --- algo.LnumStr6_U32..Eq
4561inline bool algo::LnumStr6_U32_Eq(algo::LnumStr6_U32& lhs, algo::LnumStr6_U32& rhs) {
4562 bool retval = true;
4563 retval = retval
4564 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
4565 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
4566 return retval;
4567}
4568
4569// --- algo.LnumStr6_U32..EqStrptr
4570inline bool algo::LnumStr6_U32_EqStrptr(const algo::LnumStr6_U32& lhs, const algo::strptr& rhs) {
4571 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4572}
4573
4574inline bool algo::LnumStr7_U32::operator ==(const algo::LnumStr7_U32 &rhs) const {
4575 return algo::LnumStr7_U32_Eq(const_cast<algo::LnumStr7_U32&>(*this),const_cast<algo::LnumStr7_U32&>(rhs));
4576}
4577
4578inline bool algo::LnumStr7_U32::operator !=(const algo::LnumStr7_U32 &rhs) const {
4579 return !algo::LnumStr7_U32_Eq(const_cast<algo::LnumStr7_U32&>(*this),const_cast<algo::LnumStr7_U32&>(rhs));
4580}
4581
4582inline bool algo::LnumStr7_U32::operator ==(const algo::strptr &rhs) const {
4583 return algo::LnumStr7_U32_EqStrptr(const_cast<algo::LnumStr7_U32&>(*this),rhs);
4584}
4585inline algo::LnumStr7_U32::LnumStr7_U32() {
4586 algo::LnumStr7_U32_Init(*this);
4587}
4588
4589
4590// --- algo.LnumStr7_U32.ch.Getary
4591// Access string as array of chars
4592inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr7_U32& parent) {
4593 int len = ch_N(parent);
4594 algo::aryptr<char> ret((char*)parent.ch, len);
4595 ret.elems += 7 - len;
4596 return ret;
4597}
4598
4599// --- algo.LnumStr7_U32.ch.HashStrptr
4600inline u32 algo::LnumStr7_U32_Hash(u32 prev, const algo::strptr &str) {
4601 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4602}
4603
4604// --- algo.LnumStr7_U32.ch.Init
4605inline void algo::ch_Init(algo::LnumStr7_U32 &parent) {
4606 for (int i = 0; i < 7; i++) {
4607 parent.ch[i] = '0';
4608 }
4609}
4610
4611// --- algo.LnumStr7_U32.ch.Max
4612// always return constant 7
4613inline int algo::ch_Max(algo::LnumStr7_U32& parent) {
4614 (void)parent;
4615 return 7;
4616}
4617
4618// --- algo.LnumStr7_U32.ch.N
4619inline int algo::ch_N(const algo::LnumStr7_U32& parent) {
4620 u64 ret;
4621 ret = 0;
4622 while (ret<7 && parent.ch[ret]==u8('0')) {
4623 ret++;
4624 }
4625 ret = 7 - ret;
4626 return int(ret);
4627}
4628
4629// --- algo.LnumStr7_U32.ch.AssignStrptr
4630// Copy from strptr (operator=)
4631inline void algo::LnumStr7_U32::operator =(const algo::strptr &str) {
4632 ch_SetStrptr(*this, str);
4633}
4634
4635// --- algo.LnumStr7_U32.ch.Set
4636// Copy from same type
4637// Copy value from RHS.
4638inline void algo::LnumStr7_U32::operator =(const algo::LnumStr7_U32& parent) {
4639 memcpy(ch, parent.ch, 7);
4640}
4641
4642// --- algo.LnumStr7_U32.ch.Ctor
4643inline algo::LnumStr7_U32::LnumStr7_U32(const algo::LnumStr7_U32 &rhs) {
4644 operator =(rhs);
4645}
4646
4647// --- algo.LnumStr7_U32.ch.CtorStrptr
4648inline algo::LnumStr7_U32::LnumStr7_U32(const algo::strptr &rhs) {
4649 ch_SetStrptr(*this, rhs);
4650}
4651
4652// --- algo.LnumStr7_U32.ch.Cast
4653inline algo::LnumStr7_U32::operator algo::strptr () const {
4654 return ch_Getary(*this);
4655}
4656
4657// --- algo.LnumStr7_U32..Cmp
4658inline i32 algo::LnumStr7_U32_Cmp(algo::LnumStr7_U32& lhs, algo::LnumStr7_U32& rhs) {
4659 i32 retval = 0;
4660 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4661 return retval;
4662}
4663
4664// --- algo.LnumStr7_U32..Init
4665// Set all fields to initial values.
4666inline void algo::LnumStr7_U32_Init(algo::LnumStr7_U32& parent) {
4667 for (int i = 0; i < 7; i++) {
4668 parent.ch[i] = '0';
4669 }
4670}
4671
4672// --- algo.LnumStr7_U32..Eq
4673inline bool algo::LnumStr7_U32_Eq(algo::LnumStr7_U32& lhs, algo::LnumStr7_U32& rhs) {
4674 bool retval = true;
4675 retval = retval
4676 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
4677 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
4678 &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
4679 return retval;
4680}
4681
4682// --- algo.LnumStr7_U32..EqStrptr
4683inline bool algo::LnumStr7_U32_EqStrptr(const algo::LnumStr7_U32& lhs, const algo::strptr& rhs) {
4684 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4685}
4686
4687inline bool algo::LnumStr7_U32_Base36::operator ==(const algo::LnumStr7_U32_Base36 &rhs) const {
4688 return algo::LnumStr7_U32_Base36_Eq(const_cast<algo::LnumStr7_U32_Base36&>(*this),const_cast<algo::LnumStr7_U32_Base36&>(rhs));
4689}
4690
4691inline bool algo::LnumStr7_U32_Base36::operator !=(const algo::LnumStr7_U32_Base36 &rhs) const {
4692 return !algo::LnumStr7_U32_Base36_Eq(const_cast<algo::LnumStr7_U32_Base36&>(*this),const_cast<algo::LnumStr7_U32_Base36&>(rhs));
4693}
4694
4695inline bool algo::LnumStr7_U32_Base36::operator ==(const algo::strptr &rhs) const {
4696 return algo::LnumStr7_U32_Base36_EqStrptr(const_cast<algo::LnumStr7_U32_Base36&>(*this),rhs);
4697}
4698inline algo::LnumStr7_U32_Base36::LnumStr7_U32_Base36() {
4699 algo::LnumStr7_U32_Base36_Init(*this);
4700}
4701
4702
4703// --- algo.LnumStr7_U32_Base36.ch.Getary
4704// Access string as array of chars
4705inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr7_U32_Base36& parent) {
4706 int len = ch_N(parent);
4707 algo::aryptr<char> ret((char*)parent.ch, len);
4708 ret.elems += 7 - len;
4709 return ret;
4710}
4711
4712// --- algo.LnumStr7_U32_Base36.ch.HashStrptr
4713inline u32 algo::LnumStr7_U32_Base36_Hash(u32 prev, const algo::strptr &str) {
4714 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4715}
4716
4717// --- algo.LnumStr7_U32_Base36.ch.Init
4718inline void algo::ch_Init(algo::LnumStr7_U32_Base36 &parent) {
4719 for (int i = 0; i < 7; i++) {
4720 parent.ch[i] = '0';
4721 }
4722}
4723
4724// --- algo.LnumStr7_U32_Base36.ch.Max
4725// always return constant 7
4726inline int algo::ch_Max(algo::LnumStr7_U32_Base36& parent) {
4727 (void)parent;
4728 return 7;
4729}
4730
4731// --- algo.LnumStr7_U32_Base36.ch.N
4732inline int algo::ch_N(const algo::LnumStr7_U32_Base36& parent) {
4733 u64 ret;
4734 ret = 0;
4735 while (ret<7 && parent.ch[ret]==u8('0')) {
4736 ret++;
4737 }
4738 ret = 7 - ret;
4739 return int(ret);
4740}
4741
4742// --- algo.LnumStr7_U32_Base36.ch.AssignStrptr
4743// Copy from strptr (operator=)
4744inline void algo::LnumStr7_U32_Base36::operator =(const algo::strptr &str) {
4745 ch_SetStrptr(*this, str);
4746}
4747
4748// --- algo.LnumStr7_U32_Base36.ch.Set
4749// Copy from same type
4750// Copy value from RHS.
4751inline void algo::LnumStr7_U32_Base36::operator =(const algo::LnumStr7_U32_Base36& parent) {
4752 memcpy(ch, parent.ch, 7);
4753}
4754
4755// --- algo.LnumStr7_U32_Base36.ch.Ctor
4756inline algo::LnumStr7_U32_Base36::LnumStr7_U32_Base36(const algo::LnumStr7_U32_Base36 &rhs) {
4757 operator =(rhs);
4758}
4759
4760// --- algo.LnumStr7_U32_Base36.ch.CtorStrptr
4761inline algo::LnumStr7_U32_Base36::LnumStr7_U32_Base36(const algo::strptr &rhs) {
4762 ch_SetStrptr(*this, rhs);
4763}
4764
4765// --- algo.LnumStr7_U32_Base36.ch.Cast
4766inline algo::LnumStr7_U32_Base36::operator algo::strptr () const {
4767 return ch_Getary(*this);
4768}
4769
4770// --- algo.LnumStr7_U32_Base36..Cmp
4771inline i32 algo::LnumStr7_U32_Base36_Cmp(algo::LnumStr7_U32_Base36& lhs, algo::LnumStr7_U32_Base36& rhs) {
4772 i32 retval = 0;
4773 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4774 return retval;
4775}
4776
4777// --- algo.LnumStr7_U32_Base36..Init
4778// Set all fields to initial values.
4779inline void algo::LnumStr7_U32_Base36_Init(algo::LnumStr7_U32_Base36& parent) {
4780 for (int i = 0; i < 7; i++) {
4781 parent.ch[i] = '0';
4782 }
4783}
4784
4785// --- algo.LnumStr7_U32_Base36..Eq
4786inline bool algo::LnumStr7_U32_Base36_Eq(algo::LnumStr7_U32_Base36& lhs, algo::LnumStr7_U32_Base36& rhs) {
4787 bool retval = true;
4788 retval = retval
4789 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
4790 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
4791 &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
4792 return retval;
4793}
4794
4795// --- algo.LnumStr7_U32_Base36..EqStrptr
4796inline bool algo::LnumStr7_U32_Base36_EqStrptr(const algo::LnumStr7_U32_Base36& lhs, const algo::strptr& rhs) {
4797 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4798}
4799
4800inline bool algo::LnumStr8_U32::operator ==(const algo::LnumStr8_U32 &rhs) const {
4801 return algo::LnumStr8_U32_Eq(const_cast<algo::LnumStr8_U32&>(*this),const_cast<algo::LnumStr8_U32&>(rhs));
4802}
4803
4804inline bool algo::LnumStr8_U32::operator !=(const algo::LnumStr8_U32 &rhs) const {
4805 return !algo::LnumStr8_U32_Eq(const_cast<algo::LnumStr8_U32&>(*this),const_cast<algo::LnumStr8_U32&>(rhs));
4806}
4807
4808inline bool algo::LnumStr8_U32::operator ==(const algo::strptr &rhs) const {
4809 return algo::LnumStr8_U32_EqStrptr(const_cast<algo::LnumStr8_U32&>(*this),rhs);
4810}
4811inline algo::LnumStr8_U32::LnumStr8_U32() {
4812 algo::LnumStr8_U32_Init(*this);
4813}
4814
4815
4816// --- algo.LnumStr8_U32.ch.Getary
4817// Access string as array of chars
4818inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr8_U32& parent) {
4819 int len = ch_N(parent);
4820 algo::aryptr<char> ret((char*)parent.ch, len);
4821 ret.elems += 8 - len;
4822 return ret;
4823}
4824
4825// --- algo.LnumStr8_U32.ch.HashStrptr
4826inline u32 algo::LnumStr8_U32_Hash(u32 prev, const algo::strptr &str) {
4827 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4828}
4829
4830// --- algo.LnumStr8_U32.ch.Init
4831inline void algo::ch_Init(algo::LnumStr8_U32 &parent) {
4832 for (int i = 0; i < 8; i++) {
4833 parent.ch[i] = '0';
4834 }
4835}
4836
4837// --- algo.LnumStr8_U32.ch.Max
4838// always return constant 8
4839inline int algo::ch_Max(algo::LnumStr8_U32& parent) {
4840 (void)parent;
4841 return 8;
4842}
4843
4844// --- algo.LnumStr8_U32.ch.N
4845inline int algo::ch_N(const algo::LnumStr8_U32& parent) {
4846 u64 ret;
4847 ret = 0;
4848 while (ret<8 && parent.ch[ret]==u8('0')) {
4849 ret++;
4850 }
4851 ret = 8 - ret;
4852 return int(ret);
4853}
4854
4855// --- algo.LnumStr8_U32.ch.AssignStrptr
4856// Copy from strptr (operator=)
4857inline void algo::LnumStr8_U32::operator =(const algo::strptr &str) {
4858 ch_SetStrptr(*this, str);
4859}
4860
4861// --- algo.LnumStr8_U32.ch.Set
4862// Copy from same type
4863// Copy value from RHS.
4864inline void algo::LnumStr8_U32::operator =(const algo::LnumStr8_U32& parent) {
4865 memcpy(ch, parent.ch, 8);
4866}
4867
4868// --- algo.LnumStr8_U32.ch.Ctor
4869inline algo::LnumStr8_U32::LnumStr8_U32(const algo::LnumStr8_U32 &rhs) {
4870 operator =(rhs);
4871}
4872
4873// --- algo.LnumStr8_U32.ch.CtorStrptr
4874inline algo::LnumStr8_U32::LnumStr8_U32(const algo::strptr &rhs) {
4875 ch_SetStrptr(*this, rhs);
4876}
4877
4878// --- algo.LnumStr8_U32.ch.Cast
4879inline algo::LnumStr8_U32::operator algo::strptr () const {
4880 return ch_Getary(*this);
4881}
4882
4883// --- algo.LnumStr8_U32..Cmp
4884inline i32 algo::LnumStr8_U32_Cmp(algo::LnumStr8_U32& lhs, algo::LnumStr8_U32& rhs) {
4885 i32 retval = 0;
4886 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4887 return retval;
4888}
4889
4890// --- algo.LnumStr8_U32..Init
4891// Set all fields to initial values.
4892inline void algo::LnumStr8_U32_Init(algo::LnumStr8_U32& parent) {
4893 for (int i = 0; i < 8; i++) {
4894 parent.ch[i] = '0';
4895 }
4896}
4897
4898// --- algo.LnumStr8_U32..Eq
4899inline bool algo::LnumStr8_U32_Eq(algo::LnumStr8_U32& lhs, algo::LnumStr8_U32& rhs) {
4900 bool retval = true;
4901 retval = retval
4902 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
4903 return retval;
4904}
4905
4906// --- algo.LnumStr8_U32..EqStrptr
4907inline bool algo::LnumStr8_U32_EqStrptr(const algo::LnumStr8_U32& lhs, const algo::strptr& rhs) {
4908 return algo::strptr_Eq(ch_Getary(lhs), rhs);
4909}
4910
4911inline bool algo::LnumStr8_U32_Base16::operator ==(const algo::LnumStr8_U32_Base16 &rhs) const {
4912 return algo::LnumStr8_U32_Base16_Eq(const_cast<algo::LnumStr8_U32_Base16&>(*this),const_cast<algo::LnumStr8_U32_Base16&>(rhs));
4913}
4914
4915inline bool algo::LnumStr8_U32_Base16::operator !=(const algo::LnumStr8_U32_Base16 &rhs) const {
4916 return !algo::LnumStr8_U32_Base16_Eq(const_cast<algo::LnumStr8_U32_Base16&>(*this),const_cast<algo::LnumStr8_U32_Base16&>(rhs));
4917}
4918
4919inline bool algo::LnumStr8_U32_Base16::operator ==(const algo::strptr &rhs) const {
4920 return algo::LnumStr8_U32_Base16_EqStrptr(const_cast<algo::LnumStr8_U32_Base16&>(*this),rhs);
4921}
4922inline algo::LnumStr8_U32_Base16::LnumStr8_U32_Base16() {
4923 algo::LnumStr8_U32_Base16_Init(*this);
4924}
4925
4926
4927// --- algo.LnumStr8_U32_Base16.ch.Getary
4928// Access string as array of chars
4929inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr8_U32_Base16& parent) {
4930 int len = ch_N(parent);
4931 algo::aryptr<char> ret((char*)parent.ch, len);
4932 ret.elems += 8 - len;
4933 return ret;
4934}
4935
4936// --- algo.LnumStr8_U32_Base16.ch.HashStrptr
4937inline u32 algo::LnumStr8_U32_Base16_Hash(u32 prev, const algo::strptr &str) {
4938 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
4939}
4940
4941// --- algo.LnumStr8_U32_Base16.ch.Init
4942inline void algo::ch_Init(algo::LnumStr8_U32_Base16 &parent) {
4943 for (int i = 0; i < 8; i++) {
4944 parent.ch[i] = '0';
4945 }
4946}
4947
4948// --- algo.LnumStr8_U32_Base16.ch.Max
4949// always return constant 8
4950inline int algo::ch_Max(algo::LnumStr8_U32_Base16& parent) {
4951 (void)parent;
4952 return 8;
4953}
4954
4955// --- algo.LnumStr8_U32_Base16.ch.N
4956inline int algo::ch_N(const algo::LnumStr8_U32_Base16& parent) {
4957 u64 ret;
4958 ret = 0;
4959 while (ret<8 && parent.ch[ret]==u8('0')) {
4960 ret++;
4961 }
4962 ret = 8 - ret;
4963 return int(ret);
4964}
4965
4966// --- algo.LnumStr8_U32_Base16.ch.AssignStrptr
4967// Copy from strptr (operator=)
4968inline void algo::LnumStr8_U32_Base16::operator =(const algo::strptr &str) {
4969 ch_SetStrptr(*this, str);
4970}
4971
4972// --- algo.LnumStr8_U32_Base16.ch.Set
4973// Copy from same type
4974// Copy value from RHS.
4975inline void algo::LnumStr8_U32_Base16::operator =(const algo::LnumStr8_U32_Base16& parent) {
4976 memcpy(ch, parent.ch, 8);
4977}
4978
4979// --- algo.LnumStr8_U32_Base16.ch.Ctor
4980inline algo::LnumStr8_U32_Base16::LnumStr8_U32_Base16(const algo::LnumStr8_U32_Base16 &rhs) {
4981 operator =(rhs);
4982}
4983
4984// --- algo.LnumStr8_U32_Base16.ch.CtorStrptr
4985inline algo::LnumStr8_U32_Base16::LnumStr8_U32_Base16(const algo::strptr &rhs) {
4986 ch_SetStrptr(*this, rhs);
4987}
4988
4989// --- algo.LnumStr8_U32_Base16.ch.Cast
4990inline algo::LnumStr8_U32_Base16::operator algo::strptr () const {
4991 return ch_Getary(*this);
4992}
4993
4994// --- algo.LnumStr8_U32_Base16..Cmp
4995inline i32 algo::LnumStr8_U32_Base16_Cmp(algo::LnumStr8_U32_Base16& lhs, algo::LnumStr8_U32_Base16& rhs) {
4996 i32 retval = 0;
4997 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
4998 return retval;
4999}
5000
5001// --- algo.LnumStr8_U32_Base16..Init
5002// Set all fields to initial values.
5003inline void algo::LnumStr8_U32_Base16_Init(algo::LnumStr8_U32_Base16& parent) {
5004 for (int i = 0; i < 8; i++) {
5005 parent.ch[i] = '0';
5006 }
5007}
5008
5009// --- algo.LnumStr8_U32_Base16..Eq
5010inline bool algo::LnumStr8_U32_Base16_Eq(algo::LnumStr8_U32_Base16& lhs, algo::LnumStr8_U32_Base16& rhs) {
5011 bool retval = true;
5012 retval = retval
5013 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
5014 return retval;
5015}
5016
5017// --- algo.LnumStr8_U32_Base16..EqStrptr
5018inline bool algo::LnumStr8_U32_Base16_EqStrptr(const algo::LnumStr8_U32_Base16& lhs, const algo::strptr& rhs) {
5019 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5020}
5021
5022inline bool algo::LnumStr8_U64::operator ==(const algo::LnumStr8_U64 &rhs) const {
5023 return algo::LnumStr8_U64_Eq(const_cast<algo::LnumStr8_U64&>(*this),const_cast<algo::LnumStr8_U64&>(rhs));
5024}
5025
5026inline bool algo::LnumStr8_U64::operator !=(const algo::LnumStr8_U64 &rhs) const {
5027 return !algo::LnumStr8_U64_Eq(const_cast<algo::LnumStr8_U64&>(*this),const_cast<algo::LnumStr8_U64&>(rhs));
5028}
5029
5030inline bool algo::LnumStr8_U64::operator ==(const algo::strptr &rhs) const {
5031 return algo::LnumStr8_U64_EqStrptr(const_cast<algo::LnumStr8_U64&>(*this),rhs);
5032}
5033inline algo::LnumStr8_U64::LnumStr8_U64() {
5034 algo::LnumStr8_U64_Init(*this);
5035}
5036
5037
5038// --- algo.LnumStr8_U64.ch.Getary
5039// Access string as array of chars
5040inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr8_U64& parent) {
5041 int len = ch_N(parent);
5042 algo::aryptr<char> ret((char*)parent.ch, len);
5043 ret.elems += 8 - len;
5044 return ret;
5045}
5046
5047// --- algo.LnumStr8_U64.ch.HashStrptr
5048inline u32 algo::LnumStr8_U64_Hash(u32 prev, const algo::strptr &str) {
5049 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5050}
5051
5052// --- algo.LnumStr8_U64.ch.Init
5053inline void algo::ch_Init(algo::LnumStr8_U64 &parent) {
5054 for (int i = 0; i < 8; i++) {
5055 parent.ch[i] = '0';
5056 }
5057}
5058
5059// --- algo.LnumStr8_U64.ch.Max
5060// always return constant 8
5061inline int algo::ch_Max(algo::LnumStr8_U64& parent) {
5062 (void)parent;
5063 return 8;
5064}
5065
5066// --- algo.LnumStr8_U64.ch.N
5067inline int algo::ch_N(const algo::LnumStr8_U64& parent) {
5068 u64 ret;
5069 ret = 0;
5070 while (ret<8 && parent.ch[ret]==u8('0')) {
5071 ret++;
5072 }
5073 ret = 8 - ret;
5074 return int(ret);
5075}
5076
5077// --- algo.LnumStr8_U64.ch.AssignStrptr
5078// Copy from strptr (operator=)
5079inline void algo::LnumStr8_U64::operator =(const algo::strptr &str) {
5080 ch_SetStrptr(*this, str);
5081}
5082
5083// --- algo.LnumStr8_U64.ch.Set
5084// Copy from same type
5085// Copy value from RHS.
5086inline void algo::LnumStr8_U64::operator =(const algo::LnumStr8_U64& parent) {
5087 memcpy(ch, parent.ch, 8);
5088}
5089
5090// --- algo.LnumStr8_U64.ch.Ctor
5091inline algo::LnumStr8_U64::LnumStr8_U64(const algo::LnumStr8_U64 &rhs) {
5092 operator =(rhs);
5093}
5094
5095// --- algo.LnumStr8_U64.ch.CtorStrptr
5096inline algo::LnumStr8_U64::LnumStr8_U64(const algo::strptr &rhs) {
5097 ch_SetStrptr(*this, rhs);
5098}
5099
5100// --- algo.LnumStr8_U64.ch.Cast
5101inline algo::LnumStr8_U64::operator algo::strptr () const {
5102 return ch_Getary(*this);
5103}
5104
5105// --- algo.LnumStr8_U64..Cmp
5106inline i32 algo::LnumStr8_U64_Cmp(algo::LnumStr8_U64& lhs, algo::LnumStr8_U64& rhs) {
5107 i32 retval = 0;
5108 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5109 return retval;
5110}
5111
5112// --- algo.LnumStr8_U64..Init
5113// Set all fields to initial values.
5114inline void algo::LnumStr8_U64_Init(algo::LnumStr8_U64& parent) {
5115 for (int i = 0; i < 8; i++) {
5116 parent.ch[i] = '0';
5117 }
5118}
5119
5120// --- algo.LnumStr8_U64..Eq
5121inline bool algo::LnumStr8_U64_Eq(algo::LnumStr8_U64& lhs, algo::LnumStr8_U64& rhs) {
5122 bool retval = true;
5123 retval = retval
5124 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
5125 return retval;
5126}
5127
5128// --- algo.LnumStr8_U64..EqStrptr
5129inline bool algo::LnumStr8_U64_EqStrptr(const algo::LnumStr8_U64& lhs, const algo::strptr& rhs) {
5130 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5131}
5132
5133inline bool algo::LnumStr9_U32::operator ==(const algo::LnumStr9_U32 &rhs) const {
5134 return algo::LnumStr9_U32_Eq(const_cast<algo::LnumStr9_U32&>(*this),const_cast<algo::LnumStr9_U32&>(rhs));
5135}
5136
5137inline bool algo::LnumStr9_U32::operator !=(const algo::LnumStr9_U32 &rhs) const {
5138 return !algo::LnumStr9_U32_Eq(const_cast<algo::LnumStr9_U32&>(*this),const_cast<algo::LnumStr9_U32&>(rhs));
5139}
5140
5141inline bool algo::LnumStr9_U32::operator ==(const algo::strptr &rhs) const {
5142 return algo::LnumStr9_U32_EqStrptr(const_cast<algo::LnumStr9_U32&>(*this),rhs);
5143}
5144inline algo::LnumStr9_U32::LnumStr9_U32() {
5145 algo::LnumStr9_U32_Init(*this);
5146}
5147
5148
5149// --- algo.LnumStr9_U32.ch.Getary
5150// Access string as array of chars
5151inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr9_U32& parent) {
5152 int len = ch_N(parent);
5153 algo::aryptr<char> ret((char*)parent.ch, len);
5154 ret.elems += 9 - len;
5155 return ret;
5156}
5157
5158// --- algo.LnumStr9_U32.ch.HashStrptr
5159inline u32 algo::LnumStr9_U32_Hash(u32 prev, const algo::strptr &str) {
5160 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5161}
5162
5163// --- algo.LnumStr9_U32.ch.Init
5164inline void algo::ch_Init(algo::LnumStr9_U32 &parent) {
5165 for (int i = 0; i < 9; i++) {
5166 parent.ch[i] = '0';
5167 }
5168}
5169
5170// --- algo.LnumStr9_U32.ch.Max
5171// always return constant 9
5172inline int algo::ch_Max(algo::LnumStr9_U32& parent) {
5173 (void)parent;
5174 return 9;
5175}
5176
5177// --- algo.LnumStr9_U32.ch.N
5178inline int algo::ch_N(const algo::LnumStr9_U32& parent) {
5179 u64 ret;
5180 ret = 0;
5181 while (ret<9 && parent.ch[ret]==u8('0')) {
5182 ret++;
5183 }
5184 ret = 9 - ret;
5185 return int(ret);
5186}
5187
5188// --- algo.LnumStr9_U32.ch.AssignStrptr
5189// Copy from strptr (operator=)
5190inline void algo::LnumStr9_U32::operator =(const algo::strptr &str) {
5191 ch_SetStrptr(*this, str);
5192}
5193
5194// --- algo.LnumStr9_U32.ch.Set
5195// Copy from same type
5196// Copy value from RHS.
5197inline void algo::LnumStr9_U32::operator =(const algo::LnumStr9_U32& parent) {
5198 memcpy(ch, parent.ch, 9);
5199}
5200
5201// --- algo.LnumStr9_U32.ch.Ctor
5202inline algo::LnumStr9_U32::LnumStr9_U32(const algo::LnumStr9_U32 &rhs) {
5203 operator =(rhs);
5204}
5205
5206// --- algo.LnumStr9_U32.ch.CtorStrptr
5207inline algo::LnumStr9_U32::LnumStr9_U32(const algo::strptr &rhs) {
5208 ch_SetStrptr(*this, rhs);
5209}
5210
5211// --- algo.LnumStr9_U32.ch.Cast
5212inline algo::LnumStr9_U32::operator algo::strptr () const {
5213 return ch_Getary(*this);
5214}
5215
5216// --- algo.LnumStr9_U32..Cmp
5217inline i32 algo::LnumStr9_U32_Cmp(algo::LnumStr9_U32& lhs, algo::LnumStr9_U32& rhs) {
5218 i32 retval = 0;
5219 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5220 return retval;
5221}
5222
5223// --- algo.LnumStr9_U32..Init
5224// Set all fields to initial values.
5225inline void algo::LnumStr9_U32_Init(algo::LnumStr9_U32& parent) {
5226 for (int i = 0; i < 9; i++) {
5227 parent.ch[i] = '0';
5228 }
5229}
5230
5231// --- algo.LnumStr9_U32..Eq
5232inline bool algo::LnumStr9_U32_Eq(algo::LnumStr9_U32& lhs, algo::LnumStr9_U32& rhs) {
5233 bool retval = true;
5234 retval = retval
5235 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
5236 &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
5237 return retval;
5238}
5239
5240// --- algo.LnumStr9_U32..EqStrptr
5241inline bool algo::LnumStr9_U32_EqStrptr(const algo::LnumStr9_U32& lhs, const algo::strptr& rhs) {
5242 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5243}
5244
5245inline bool algo::LnumStr9_U64::operator ==(const algo::LnumStr9_U64 &rhs) const {
5246 return algo::LnumStr9_U64_Eq(const_cast<algo::LnumStr9_U64&>(*this),const_cast<algo::LnumStr9_U64&>(rhs));
5247}
5248
5249inline bool algo::LnumStr9_U64::operator !=(const algo::LnumStr9_U64 &rhs) const {
5250 return !algo::LnumStr9_U64_Eq(const_cast<algo::LnumStr9_U64&>(*this),const_cast<algo::LnumStr9_U64&>(rhs));
5251}
5252
5253inline bool algo::LnumStr9_U64::operator ==(const algo::strptr &rhs) const {
5254 return algo::LnumStr9_U64_EqStrptr(const_cast<algo::LnumStr9_U64&>(*this),rhs);
5255}
5256inline algo::LnumStr9_U64::LnumStr9_U64() {
5257 algo::LnumStr9_U64_Init(*this);
5258}
5259
5260
5261// --- algo.LnumStr9_U64.ch.Getary
5262// Access string as array of chars
5263inline algo::aryptr<char> algo::ch_Getary(const algo::LnumStr9_U64& parent) {
5264 int len = ch_N(parent);
5265 algo::aryptr<char> ret((char*)parent.ch, len);
5266 ret.elems += 9 - len;
5267 return ret;
5268}
5269
5270// --- algo.LnumStr9_U64.ch.HashStrptr
5271inline u32 algo::LnumStr9_U64_Hash(u32 prev, const algo::strptr &str) {
5272 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5273}
5274
5275// --- algo.LnumStr9_U64.ch.Init
5276inline void algo::ch_Init(algo::LnumStr9_U64 &parent) {
5277 for (int i = 0; i < 9; i++) {
5278 parent.ch[i] = '0';
5279 }
5280}
5281
5282// --- algo.LnumStr9_U64.ch.Max
5283// always return constant 9
5284inline int algo::ch_Max(algo::LnumStr9_U64& parent) {
5285 (void)parent;
5286 return 9;
5287}
5288
5289// --- algo.LnumStr9_U64.ch.N
5290inline int algo::ch_N(const algo::LnumStr9_U64& parent) {
5291 u64 ret;
5292 ret = 0;
5293 while (ret<9 && parent.ch[ret]==u8('0')) {
5294 ret++;
5295 }
5296 ret = 9 - ret;
5297 return int(ret);
5298}
5299
5300// --- algo.LnumStr9_U64.ch.AssignStrptr
5301// Copy from strptr (operator=)
5302inline void algo::LnumStr9_U64::operator =(const algo::strptr &str) {
5303 ch_SetStrptr(*this, str);
5304}
5305
5306// --- algo.LnumStr9_U64.ch.Set
5307// Copy from same type
5308// Copy value from RHS.
5309inline void algo::LnumStr9_U64::operator =(const algo::LnumStr9_U64& parent) {
5310 memcpy(ch, parent.ch, 9);
5311}
5312
5313// --- algo.LnumStr9_U64.ch.Ctor
5314inline algo::LnumStr9_U64::LnumStr9_U64(const algo::LnumStr9_U64 &rhs) {
5315 operator =(rhs);
5316}
5317
5318// --- algo.LnumStr9_U64.ch.CtorStrptr
5319inline algo::LnumStr9_U64::LnumStr9_U64(const algo::strptr &rhs) {
5320 ch_SetStrptr(*this, rhs);
5321}
5322
5323// --- algo.LnumStr9_U64.ch.Cast
5324inline algo::LnumStr9_U64::operator algo::strptr () const {
5325 return ch_Getary(*this);
5326}
5327
5328// --- algo.LnumStr9_U64..Cmp
5329inline i32 algo::LnumStr9_U64_Cmp(algo::LnumStr9_U64& lhs, algo::LnumStr9_U64& rhs) {
5330 i32 retval = 0;
5331 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5332 return retval;
5333}
5334
5335// --- algo.LnumStr9_U64..Init
5336// Set all fields to initial values.
5337inline void algo::LnumStr9_U64_Init(algo::LnumStr9_U64& parent) {
5338 for (int i = 0; i < 9; i++) {
5339 parent.ch[i] = '0';
5340 }
5341}
5342
5343// --- algo.LnumStr9_U64..Eq
5344inline bool algo::LnumStr9_U64_Eq(algo::LnumStr9_U64& lhs, algo::LnumStr9_U64& rhs) {
5345 bool retval = true;
5346 retval = retval
5347 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
5348 &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
5349 return retval;
5350}
5351
5352// --- algo.LnumStr9_U64..EqStrptr
5353inline bool algo::LnumStr9_U64_EqStrptr(const algo::LnumStr9_U64& lhs, const algo::strptr& rhs) {
5354 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5355}
5356
5357inline bool algo::LspaceStr10::operator ==(const algo::LspaceStr10 &rhs) const {
5358 return algo::LspaceStr10_Eq(const_cast<algo::LspaceStr10&>(*this),const_cast<algo::LspaceStr10&>(rhs));
5359}
5360
5361inline bool algo::LspaceStr10::operator !=(const algo::LspaceStr10 &rhs) const {
5362 return !algo::LspaceStr10_Eq(const_cast<algo::LspaceStr10&>(*this),const_cast<algo::LspaceStr10&>(rhs));
5363}
5364
5365inline bool algo::LspaceStr10::operator ==(const algo::strptr &rhs) const {
5366 return algo::LspaceStr10_EqStrptr(const_cast<algo::LspaceStr10&>(*this),rhs);
5367}
5368inline algo::LspaceStr10::LspaceStr10() {
5369 algo::LspaceStr10_Init(*this);
5370}
5371
5372
5373// --- algo.LspaceStr10.ch.Getary
5374// Access string as array of chars
5375inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr10& parent) {
5376 int len = ch_N(parent);
5377 algo::aryptr<char> ret((char*)parent.ch, len);
5378 ret.elems += 10 - len;
5379 return ret;
5380}
5381
5382// --- algo.LspaceStr10.ch.HashStrptr
5383inline u32 algo::LspaceStr10_Hash(u32 prev, const algo::strptr &str) {
5384 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5385}
5386
5387// --- algo.LspaceStr10.ch.Init
5388inline void algo::ch_Init(algo::LspaceStr10 &parent) {
5389 memset(parent.ch, ' ', 10);
5390}
5391
5392// --- algo.LspaceStr10.ch.Max
5393// always return constant 10
5394inline int algo::ch_Max(algo::LspaceStr10& parent) {
5395 (void)parent;
5396 return 10;
5397}
5398
5399// --- algo.LspaceStr10.ch.N
5400inline int algo::ch_N(const algo::LspaceStr10& parent) {
5401 u64 ret;
5402 ret = 0;
5403 while (ret<10 && parent.ch[ret]==u8(' ')) {
5404 ret++;
5405 }
5406 ret = 10 - ret;
5407 return int(ret);
5408}
5409
5410// --- algo.LspaceStr10.ch.AssignStrptr
5411// Copy from strptr (operator=)
5412inline void algo::LspaceStr10::operator =(const algo::strptr &str) {
5413 ch_SetStrptr(*this, str);
5414}
5415
5416// --- algo.LspaceStr10.ch.Set
5417// Copy from same type
5418// Copy value from RHS.
5419inline void algo::LspaceStr10::operator =(const algo::LspaceStr10& parent) {
5420 memcpy(ch, parent.ch, 10);
5421}
5422
5423// --- algo.LspaceStr10.ch.Ctor
5424inline algo::LspaceStr10::LspaceStr10(const algo::LspaceStr10 &rhs) {
5425 operator =(rhs);
5426}
5427
5428// --- algo.LspaceStr10.ch.CtorStrptr
5429inline algo::LspaceStr10::LspaceStr10(const algo::strptr &rhs) {
5430 ch_SetStrptr(*this, rhs);
5431}
5432
5433// --- algo.LspaceStr10.ch.Cast
5434inline algo::LspaceStr10::operator algo::strptr () const {
5435 return ch_Getary(*this);
5436}
5437
5438// --- algo.LspaceStr10..Cmp
5439inline i32 algo::LspaceStr10_Cmp(algo::LspaceStr10& lhs, algo::LspaceStr10& rhs) {
5440 i32 retval = 0;
5441 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5442 return retval;
5443}
5444
5445// --- algo.LspaceStr10..Init
5446// Set all fields to initial values.
5447inline void algo::LspaceStr10_Init(algo::LspaceStr10& parent) {
5448 memset(parent.ch, ' ', 10);
5449}
5450
5451// --- algo.LspaceStr10..Eq
5452inline bool algo::LspaceStr10_Eq(algo::LspaceStr10& lhs, algo::LspaceStr10& rhs) {
5453 bool retval = true;
5454 retval = retval
5455 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
5456 &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8);
5457 return retval;
5458}
5459
5460// --- algo.LspaceStr10..EqStrptr
5461inline bool algo::LspaceStr10_EqStrptr(const algo::LspaceStr10& lhs, const algo::strptr& rhs) {
5462 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5463}
5464
5465inline bool algo::LspaceStr12::operator ==(const algo::LspaceStr12 &rhs) const {
5466 return algo::LspaceStr12_Eq(const_cast<algo::LspaceStr12&>(*this),const_cast<algo::LspaceStr12&>(rhs));
5467}
5468
5469inline bool algo::LspaceStr12::operator !=(const algo::LspaceStr12 &rhs) const {
5470 return !algo::LspaceStr12_Eq(const_cast<algo::LspaceStr12&>(*this),const_cast<algo::LspaceStr12&>(rhs));
5471}
5472
5473inline bool algo::LspaceStr12::operator ==(const algo::strptr &rhs) const {
5474 return algo::LspaceStr12_EqStrptr(const_cast<algo::LspaceStr12&>(*this),rhs);
5475}
5476inline algo::LspaceStr12::LspaceStr12() {
5477 algo::LspaceStr12_Init(*this);
5478}
5479
5480
5481// --- algo.LspaceStr12.ch.Getary
5482// Access string as array of chars
5483inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr12& parent) {
5484 int len = ch_N(parent);
5485 algo::aryptr<char> ret((char*)parent.ch, len);
5486 ret.elems += 12 - len;
5487 return ret;
5488}
5489
5490// --- algo.LspaceStr12.ch.HashStrptr
5491inline u32 algo::LspaceStr12_Hash(u32 prev, const algo::strptr &str) {
5492 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5493}
5494
5495// --- algo.LspaceStr12.ch.Init
5496inline void algo::ch_Init(algo::LspaceStr12 &parent) {
5497 memset(parent.ch, ' ', 12);
5498}
5499
5500// --- algo.LspaceStr12.ch.Max
5501// always return constant 12
5502inline int algo::ch_Max(algo::LspaceStr12& parent) {
5503 (void)parent;
5504 return 12;
5505}
5506
5507// --- algo.LspaceStr12.ch.N
5508inline int algo::ch_N(const algo::LspaceStr12& parent) {
5509 u64 ret;
5510 ret = 0;
5511 while (ret<12 && parent.ch[ret]==u8(' ')) {
5512 ret++;
5513 }
5514 ret = 12 - ret;
5515 return int(ret);
5516}
5517
5518// --- algo.LspaceStr12.ch.AssignStrptr
5519// Copy from strptr (operator=)
5520inline void algo::LspaceStr12::operator =(const algo::strptr &str) {
5521 ch_SetStrptr(*this, str);
5522}
5523
5524// --- algo.LspaceStr12.ch.Set
5525// Copy from same type
5526// Copy value from RHS.
5527inline void algo::LspaceStr12::operator =(const algo::LspaceStr12& parent) {
5528 memcpy(ch, parent.ch, 12);
5529}
5530
5531// --- algo.LspaceStr12.ch.Ctor
5532inline algo::LspaceStr12::LspaceStr12(const algo::LspaceStr12 &rhs) {
5533 operator =(rhs);
5534}
5535
5536// --- algo.LspaceStr12.ch.CtorStrptr
5537inline algo::LspaceStr12::LspaceStr12(const algo::strptr &rhs) {
5538 ch_SetStrptr(*this, rhs);
5539}
5540
5541// --- algo.LspaceStr12.ch.Cast
5542inline algo::LspaceStr12::operator algo::strptr () const {
5543 return ch_Getary(*this);
5544}
5545
5546// --- algo.LspaceStr12..Cmp
5547inline i32 algo::LspaceStr12_Cmp(algo::LspaceStr12& lhs, algo::LspaceStr12& rhs) {
5548 i32 retval = 0;
5549 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5550 return retval;
5551}
5552
5553// --- algo.LspaceStr12..Init
5554// Set all fields to initial values.
5555inline void algo::LspaceStr12_Init(algo::LspaceStr12& parent) {
5556 memset(parent.ch, ' ', 12);
5557}
5558
5559// --- algo.LspaceStr12..Eq
5560inline bool algo::LspaceStr12_Eq(algo::LspaceStr12& lhs, algo::LspaceStr12& rhs) {
5561 bool retval = true;
5562 retval = retval
5563 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
5564 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8);
5565 return retval;
5566}
5567
5568// --- algo.LspaceStr12..EqStrptr
5569inline bool algo::LspaceStr12_EqStrptr(const algo::LspaceStr12& lhs, const algo::strptr& rhs) {
5570 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5571}
5572
5573inline bool algo::LspaceStr14::operator ==(const algo::LspaceStr14 &rhs) const {
5574 return algo::LspaceStr14_Eq(const_cast<algo::LspaceStr14&>(*this),const_cast<algo::LspaceStr14&>(rhs));
5575}
5576
5577inline bool algo::LspaceStr14::operator !=(const algo::LspaceStr14 &rhs) const {
5578 return !algo::LspaceStr14_Eq(const_cast<algo::LspaceStr14&>(*this),const_cast<algo::LspaceStr14&>(rhs));
5579}
5580
5581inline bool algo::LspaceStr14::operator ==(const algo::strptr &rhs) const {
5582 return algo::LspaceStr14_EqStrptr(const_cast<algo::LspaceStr14&>(*this),rhs);
5583}
5584inline algo::LspaceStr14::LspaceStr14() {
5585 algo::LspaceStr14_Init(*this);
5586}
5587
5588
5589// --- algo.LspaceStr14.ch.Getary
5590// Access string as array of chars
5591inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr14& parent) {
5592 int len = ch_N(parent);
5593 algo::aryptr<char> ret((char*)parent.ch, len);
5594 ret.elems += 14 - len;
5595 return ret;
5596}
5597
5598// --- algo.LspaceStr14.ch.HashStrptr
5599inline u32 algo::LspaceStr14_Hash(u32 prev, const algo::strptr &str) {
5600 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5601}
5602
5603// --- algo.LspaceStr14.ch.Init
5604inline void algo::ch_Init(algo::LspaceStr14 &parent) {
5605 memset(parent.ch, ' ', 14);
5606}
5607
5608// --- algo.LspaceStr14.ch.Max
5609// always return constant 14
5610inline int algo::ch_Max(algo::LspaceStr14& parent) {
5611 (void)parent;
5612 return 14;
5613}
5614
5615// --- algo.LspaceStr14.ch.N
5616inline int algo::ch_N(const algo::LspaceStr14& parent) {
5617 u64 ret;
5618 ret = 0;
5619 while (ret<14 && parent.ch[ret]==u8(' ')) {
5620 ret++;
5621 }
5622 ret = 14 - ret;
5623 return int(ret);
5624}
5625
5626// --- algo.LspaceStr14.ch.AssignStrptr
5627// Copy from strptr (operator=)
5628inline void algo::LspaceStr14::operator =(const algo::strptr &str) {
5629 ch_SetStrptr(*this, str);
5630}
5631
5632// --- algo.LspaceStr14.ch.Set
5633// Copy from same type
5634// Copy value from RHS.
5635inline void algo::LspaceStr14::operator =(const algo::LspaceStr14& parent) {
5636 memcpy(ch, parent.ch, 14);
5637}
5638
5639// --- algo.LspaceStr14.ch.Ctor
5640inline algo::LspaceStr14::LspaceStr14(const algo::LspaceStr14 &rhs) {
5641 operator =(rhs);
5642}
5643
5644// --- algo.LspaceStr14.ch.CtorStrptr
5645inline algo::LspaceStr14::LspaceStr14(const algo::strptr &rhs) {
5646 ch_SetStrptr(*this, rhs);
5647}
5648
5649// --- algo.LspaceStr14.ch.Cast
5650inline algo::LspaceStr14::operator algo::strptr () const {
5651 return ch_Getary(*this);
5652}
5653
5654// --- algo.LspaceStr14..Cmp
5655inline i32 algo::LspaceStr14_Cmp(algo::LspaceStr14& lhs, algo::LspaceStr14& rhs) {
5656 i32 retval = 0;
5657 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5658 return retval;
5659}
5660
5661// --- algo.LspaceStr14..Init
5662// Set all fields to initial values.
5663inline void algo::LspaceStr14_Init(algo::LspaceStr14& parent) {
5664 memset(parent.ch, ' ', 14);
5665}
5666
5667// --- algo.LspaceStr14..Eq
5668inline bool algo::LspaceStr14_Eq(algo::LspaceStr14& lhs, algo::LspaceStr14& rhs) {
5669 bool retval = true;
5670 retval = retval
5671 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
5672 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
5673 &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12);
5674 return retval;
5675}
5676
5677// --- algo.LspaceStr14..EqStrptr
5678inline bool algo::LspaceStr14_EqStrptr(const algo::LspaceStr14& lhs, const algo::strptr& rhs) {
5679 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5680}
5681
5682inline bool algo::LspaceStr15::operator ==(const algo::LspaceStr15 &rhs) const {
5683 return algo::LspaceStr15_Eq(const_cast<algo::LspaceStr15&>(*this),const_cast<algo::LspaceStr15&>(rhs));
5684}
5685
5686inline bool algo::LspaceStr15::operator !=(const algo::LspaceStr15 &rhs) const {
5687 return !algo::LspaceStr15_Eq(const_cast<algo::LspaceStr15&>(*this),const_cast<algo::LspaceStr15&>(rhs));
5688}
5689
5690inline bool algo::LspaceStr15::operator ==(const algo::strptr &rhs) const {
5691 return algo::LspaceStr15_EqStrptr(const_cast<algo::LspaceStr15&>(*this),rhs);
5692}
5693inline algo::LspaceStr15::LspaceStr15() {
5694 algo::LspaceStr15_Init(*this);
5695}
5696
5697
5698// --- algo.LspaceStr15.ch.Getary
5699// Access string as array of chars
5700inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr15& parent) {
5701 int len = ch_N(parent);
5702 algo::aryptr<char> ret((char*)parent.ch, len);
5703 ret.elems += 15 - len;
5704 return ret;
5705}
5706
5707// --- algo.LspaceStr15.ch.HashStrptr
5708inline u32 algo::LspaceStr15_Hash(u32 prev, const algo::strptr &str) {
5709 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5710}
5711
5712// --- algo.LspaceStr15.ch.Init
5713inline void algo::ch_Init(algo::LspaceStr15 &parent) {
5714 memset(parent.ch, ' ', 15);
5715}
5716
5717// --- algo.LspaceStr15.ch.Max
5718// always return constant 15
5719inline int algo::ch_Max(algo::LspaceStr15& parent) {
5720 (void)parent;
5721 return 15;
5722}
5723
5724// --- algo.LspaceStr15.ch.N
5725inline int algo::ch_N(const algo::LspaceStr15& parent) {
5726 u64 ret;
5727 ret = 0;
5728 while (ret<15 && parent.ch[ret]==u8(' ')) {
5729 ret++;
5730 }
5731 ret = 15 - ret;
5732 return int(ret);
5733}
5734
5735// --- algo.LspaceStr15.ch.AssignStrptr
5736// Copy from strptr (operator=)
5737inline void algo::LspaceStr15::operator =(const algo::strptr &str) {
5738 ch_SetStrptr(*this, str);
5739}
5740
5741// --- algo.LspaceStr15.ch.Set
5742// Copy from same type
5743// Copy value from RHS.
5744inline void algo::LspaceStr15::operator =(const algo::LspaceStr15& parent) {
5745 memcpy(ch, parent.ch, 15);
5746}
5747
5748// --- algo.LspaceStr15.ch.Ctor
5749inline algo::LspaceStr15::LspaceStr15(const algo::LspaceStr15 &rhs) {
5750 operator =(rhs);
5751}
5752
5753// --- algo.LspaceStr15.ch.CtorStrptr
5754inline algo::LspaceStr15::LspaceStr15(const algo::strptr &rhs) {
5755 ch_SetStrptr(*this, rhs);
5756}
5757
5758// --- algo.LspaceStr15.ch.Cast
5759inline algo::LspaceStr15::operator algo::strptr () const {
5760 return ch_Getary(*this);
5761}
5762
5763// --- algo.LspaceStr15..Cmp
5764inline i32 algo::LspaceStr15_Cmp(algo::LspaceStr15& lhs, algo::LspaceStr15& rhs) {
5765 i32 retval = 0;
5766 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5767 return retval;
5768}
5769
5770// --- algo.LspaceStr15..Init
5771// Set all fields to initial values.
5772inline void algo::LspaceStr15_Init(algo::LspaceStr15& parent) {
5773 memset(parent.ch, ' ', 15);
5774}
5775
5776// --- algo.LspaceStr15..Eq
5777inline bool algo::LspaceStr15_Eq(algo::LspaceStr15& lhs, algo::LspaceStr15& rhs) {
5778 bool retval = true;
5779 retval = retval
5780 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
5781 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
5782 &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12)
5783 &&*(u8*)(lhs.ch+14) == *(u8*)(rhs.ch+14);
5784 return retval;
5785}
5786
5787// --- algo.LspaceStr15..EqStrptr
5788inline bool algo::LspaceStr15_EqStrptr(const algo::LspaceStr15& lhs, const algo::strptr& rhs) {
5789 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5790}
5791
5792inline bool algo::LspaceStr20_I64::operator ==(const algo::LspaceStr20_I64 &rhs) const {
5793 return algo::LspaceStr20_I64_Eq(const_cast<algo::LspaceStr20_I64&>(*this),const_cast<algo::LspaceStr20_I64&>(rhs));
5794}
5795
5796inline bool algo::LspaceStr20_I64::operator !=(const algo::LspaceStr20_I64 &rhs) const {
5797 return !algo::LspaceStr20_I64_Eq(const_cast<algo::LspaceStr20_I64&>(*this),const_cast<algo::LspaceStr20_I64&>(rhs));
5798}
5799
5800inline bool algo::LspaceStr20_I64::operator ==(const algo::strptr &rhs) const {
5801 return algo::LspaceStr20_I64_EqStrptr(const_cast<algo::LspaceStr20_I64&>(*this),rhs);
5802}
5803inline algo::LspaceStr20_I64::LspaceStr20_I64() {
5804 algo::LspaceStr20_I64_Init(*this);
5805}
5806
5807
5808// --- algo.LspaceStr20_I64.ch.Getary
5809// Access string as array of chars
5810inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr20_I64& parent) {
5811 int len = ch_N(parent);
5812 algo::aryptr<char> ret((char*)parent.ch, len);
5813 ret.elems += 20 - len;
5814 return ret;
5815}
5816
5817// --- algo.LspaceStr20_I64.ch.HashStrptr
5818inline u32 algo::LspaceStr20_I64_Hash(u32 prev, const algo::strptr &str) {
5819 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5820}
5821
5822// --- algo.LspaceStr20_I64.ch.Init
5823inline void algo::ch_Init(algo::LspaceStr20_I64 &parent) {
5824 memset(parent.ch, ' ', 20);
5825}
5826
5827// --- algo.LspaceStr20_I64.ch.Max
5828// always return constant 20
5829inline int algo::ch_Max(algo::LspaceStr20_I64& parent) {
5830 (void)parent;
5831 return 20;
5832}
5833
5834// --- algo.LspaceStr20_I64.ch.N
5835inline int algo::ch_N(const algo::LspaceStr20_I64& parent) {
5836 u64 ret;
5837 ret = 0;
5838 while (ret<20 && parent.ch[ret]==u8(' ')) {
5839 ret++;
5840 }
5841 ret = 20 - ret;
5842 return int(ret);
5843}
5844
5845// --- algo.LspaceStr20_I64.ch.AssignStrptr
5846// Copy from strptr (operator=)
5847inline void algo::LspaceStr20_I64::operator =(const algo::strptr &str) {
5848 ch_SetStrptr(*this, str);
5849}
5850
5851// --- algo.LspaceStr20_I64.ch.Set
5852// Copy from same type
5853// Copy value from RHS.
5854inline void algo::LspaceStr20_I64::operator =(const algo::LspaceStr20_I64& parent) {
5855 memcpy(ch, parent.ch, 20);
5856}
5857
5858// --- algo.LspaceStr20_I64.ch.Ctor
5859inline algo::LspaceStr20_I64::LspaceStr20_I64(const algo::LspaceStr20_I64 &rhs) {
5860 operator =(rhs);
5861}
5862
5863// --- algo.LspaceStr20_I64.ch.CtorStrptr
5864inline algo::LspaceStr20_I64::LspaceStr20_I64(const algo::strptr &rhs) {
5865 ch_SetStrptr(*this, rhs);
5866}
5867
5868// --- algo.LspaceStr20_I64.ch.Cast
5869inline algo::LspaceStr20_I64::operator algo::strptr () const {
5870 return ch_Getary(*this);
5871}
5872
5873// --- algo.LspaceStr20_I64..Cmp
5874inline i32 algo::LspaceStr20_I64_Cmp(algo::LspaceStr20_I64& lhs, algo::LspaceStr20_I64& rhs) {
5875 i32 retval = 0;
5876 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5877 return retval;
5878}
5879
5880// --- algo.LspaceStr20_I64..Init
5881// Set all fields to initial values.
5882inline void algo::LspaceStr20_I64_Init(algo::LspaceStr20_I64& parent) {
5883 memset(parent.ch, ' ', 20);
5884}
5885
5886// --- algo.LspaceStr20_I64..Eq
5887inline bool algo::LspaceStr20_I64_Eq(algo::LspaceStr20_I64& lhs, algo::LspaceStr20_I64& rhs) {
5888 bool retval = true;
5889 retval = retval
5890 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
5891 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
5892 &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
5893 return retval;
5894}
5895
5896// --- algo.LspaceStr20_I64..EqStrptr
5897inline bool algo::LspaceStr20_I64_EqStrptr(const algo::LspaceStr20_I64& lhs, const algo::strptr& rhs) {
5898 return algo::strptr_Eq(ch_Getary(lhs), rhs);
5899}
5900
5901inline bool algo::LspaceStr20_U64::operator ==(const algo::LspaceStr20_U64 &rhs) const {
5902 return algo::LspaceStr20_U64_Eq(const_cast<algo::LspaceStr20_U64&>(*this),const_cast<algo::LspaceStr20_U64&>(rhs));
5903}
5904
5905inline bool algo::LspaceStr20_U64::operator !=(const algo::LspaceStr20_U64 &rhs) const {
5906 return !algo::LspaceStr20_U64_Eq(const_cast<algo::LspaceStr20_U64&>(*this),const_cast<algo::LspaceStr20_U64&>(rhs));
5907}
5908
5909inline bool algo::LspaceStr20_U64::operator ==(const algo::strptr &rhs) const {
5910 return algo::LspaceStr20_U64_EqStrptr(const_cast<algo::LspaceStr20_U64&>(*this),rhs);
5911}
5912inline algo::LspaceStr20_U64::LspaceStr20_U64() {
5913 algo::LspaceStr20_U64_Init(*this);
5914}
5915
5916
5917// --- algo.LspaceStr20_U64.ch.Getary
5918// Access string as array of chars
5919inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr20_U64& parent) {
5920 int len = ch_N(parent);
5921 algo::aryptr<char> ret((char*)parent.ch, len);
5922 ret.elems += 20 - len;
5923 return ret;
5924}
5925
5926// --- algo.LspaceStr20_U64.ch.HashStrptr
5927inline u32 algo::LspaceStr20_U64_Hash(u32 prev, const algo::strptr &str) {
5928 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
5929}
5930
5931// --- algo.LspaceStr20_U64.ch.Init
5932inline void algo::ch_Init(algo::LspaceStr20_U64 &parent) {
5933 memset(parent.ch, ' ', 20);
5934}
5935
5936// --- algo.LspaceStr20_U64.ch.Max
5937// always return constant 20
5938inline int algo::ch_Max(algo::LspaceStr20_U64& parent) {
5939 (void)parent;
5940 return 20;
5941}
5942
5943// --- algo.LspaceStr20_U64.ch.N
5944inline int algo::ch_N(const algo::LspaceStr20_U64& parent) {
5945 u64 ret;
5946 ret = 0;
5947 while (ret<20 && parent.ch[ret]==u8(' ')) {
5948 ret++;
5949 }
5950 ret = 20 - ret;
5951 return int(ret);
5952}
5953
5954// --- algo.LspaceStr20_U64.ch.AssignStrptr
5955// Copy from strptr (operator=)
5956inline void algo::LspaceStr20_U64::operator =(const algo::strptr &str) {
5957 ch_SetStrptr(*this, str);
5958}
5959
5960// --- algo.LspaceStr20_U64.ch.Set
5961// Copy from same type
5962// Copy value from RHS.
5963inline void algo::LspaceStr20_U64::operator =(const algo::LspaceStr20_U64& parent) {
5964 memcpy(ch, parent.ch, 20);
5965}
5966
5967// --- algo.LspaceStr20_U64.ch.Ctor
5968inline algo::LspaceStr20_U64::LspaceStr20_U64(const algo::LspaceStr20_U64 &rhs) {
5969 operator =(rhs);
5970}
5971
5972// --- algo.LspaceStr20_U64.ch.CtorStrptr
5973inline algo::LspaceStr20_U64::LspaceStr20_U64(const algo::strptr &rhs) {
5974 ch_SetStrptr(*this, rhs);
5975}
5976
5977// --- algo.LspaceStr20_U64.ch.Cast
5978inline algo::LspaceStr20_U64::operator algo::strptr () const {
5979 return ch_Getary(*this);
5980}
5981
5982// --- algo.LspaceStr20_U64..Cmp
5983inline i32 algo::LspaceStr20_U64_Cmp(algo::LspaceStr20_U64& lhs, algo::LspaceStr20_U64& rhs) {
5984 i32 retval = 0;
5985 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
5986 return retval;
5987}
5988
5989// --- algo.LspaceStr20_U64..Init
5990// Set all fields to initial values.
5991inline void algo::LspaceStr20_U64_Init(algo::LspaceStr20_U64& parent) {
5992 memset(parent.ch, ' ', 20);
5993}
5994
5995// --- algo.LspaceStr20_U64..Eq
5996inline bool algo::LspaceStr20_U64_Eq(algo::LspaceStr20_U64& lhs, algo::LspaceStr20_U64& rhs) {
5997 bool retval = true;
5998 retval = retval
5999 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
6000 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
6001 &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
6002 return retval;
6003}
6004
6005// --- algo.LspaceStr20_U64..EqStrptr
6006inline bool algo::LspaceStr20_U64_EqStrptr(const algo::LspaceStr20_U64& lhs, const algo::strptr& rhs) {
6007 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6008}
6009
6010inline bool algo::LspaceStr3::operator ==(const algo::LspaceStr3 &rhs) const {
6011 return algo::LspaceStr3_Eq(const_cast<algo::LspaceStr3&>(*this),const_cast<algo::LspaceStr3&>(rhs));
6012}
6013
6014inline bool algo::LspaceStr3::operator !=(const algo::LspaceStr3 &rhs) const {
6015 return !algo::LspaceStr3_Eq(const_cast<algo::LspaceStr3&>(*this),const_cast<algo::LspaceStr3&>(rhs));
6016}
6017
6018inline bool algo::LspaceStr3::operator ==(const algo::strptr &rhs) const {
6019 return algo::LspaceStr3_EqStrptr(const_cast<algo::LspaceStr3&>(*this),rhs);
6020}
6021inline algo::LspaceStr3::LspaceStr3() {
6022 algo::LspaceStr3_Init(*this);
6023}
6024
6025
6026// --- algo.LspaceStr3.ch.Getary
6027// Access string as array of chars
6028inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr3& parent) {
6029 int len = ch_N(parent);
6030 algo::aryptr<char> ret((char*)parent.ch, len);
6031 ret.elems += 3 - len;
6032 return ret;
6033}
6034
6035// --- algo.LspaceStr3.ch.HashStrptr
6036inline u32 algo::LspaceStr3_Hash(u32 prev, const algo::strptr &str) {
6037 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6038}
6039
6040// --- algo.LspaceStr3.ch.Init
6041inline void algo::ch_Init(algo::LspaceStr3 &parent) {
6042 memset(parent.ch, ' ', 3);
6043}
6044
6045// --- algo.LspaceStr3.ch.Max
6046// always return constant 3
6047inline int algo::ch_Max(algo::LspaceStr3& parent) {
6048 (void)parent;
6049 return 3;
6050}
6051
6052// --- algo.LspaceStr3.ch.N
6053inline int algo::ch_N(const algo::LspaceStr3& parent) {
6054 u64 ret;
6055 ret = 0;
6056 while (ret<3 && parent.ch[ret]==u8(' ')) {
6057 ret++;
6058 }
6059 ret = 3 - ret;
6060 return int(ret);
6061}
6062
6063// --- algo.LspaceStr3.ch.AssignStrptr
6064// Copy from strptr (operator=)
6065inline void algo::LspaceStr3::operator =(const algo::strptr &str) {
6066 ch_SetStrptr(*this, str);
6067}
6068
6069// --- algo.LspaceStr3.ch.Set
6070// Copy from same type
6071// Copy value from RHS.
6072inline void algo::LspaceStr3::operator =(const algo::LspaceStr3& parent) {
6073 memcpy(ch, parent.ch, 3);
6074}
6075
6076// --- algo.LspaceStr3.ch.Ctor
6077inline algo::LspaceStr3::LspaceStr3(const algo::LspaceStr3 &rhs) {
6078 operator =(rhs);
6079}
6080
6081// --- algo.LspaceStr3.ch.CtorStrptr
6082inline algo::LspaceStr3::LspaceStr3(const algo::strptr &rhs) {
6083 ch_SetStrptr(*this, rhs);
6084}
6085
6086// --- algo.LspaceStr3.ch.Cast
6087inline algo::LspaceStr3::operator algo::strptr () const {
6088 return ch_Getary(*this);
6089}
6090
6091// --- algo.LspaceStr3..Cmp
6092inline i32 algo::LspaceStr3_Cmp(algo::LspaceStr3& lhs, algo::LspaceStr3& rhs) {
6093 i32 retval = 0;
6094 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6095 return retval;
6096}
6097
6098// --- algo.LspaceStr3..Init
6099// Set all fields to initial values.
6100inline void algo::LspaceStr3_Init(algo::LspaceStr3& parent) {
6101 memset(parent.ch, ' ', 3);
6102}
6103
6104// --- algo.LspaceStr3..Eq
6105inline bool algo::LspaceStr3_Eq(algo::LspaceStr3& lhs, algo::LspaceStr3& rhs) {
6106 bool retval = true;
6107 retval = retval
6108 &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
6109 &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
6110 return retval;
6111}
6112
6113// --- algo.LspaceStr3..EqStrptr
6114inline bool algo::LspaceStr3_EqStrptr(const algo::LspaceStr3& lhs, const algo::strptr& rhs) {
6115 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6116}
6117
6118inline bool algo::LspaceStr3_I16::operator ==(const algo::LspaceStr3_I16 &rhs) const {
6119 return algo::LspaceStr3_I16_Eq(const_cast<algo::LspaceStr3_I16&>(*this),const_cast<algo::LspaceStr3_I16&>(rhs));
6120}
6121
6122inline bool algo::LspaceStr3_I16::operator !=(const algo::LspaceStr3_I16 &rhs) const {
6123 return !algo::LspaceStr3_I16_Eq(const_cast<algo::LspaceStr3_I16&>(*this),const_cast<algo::LspaceStr3_I16&>(rhs));
6124}
6125
6126inline bool algo::LspaceStr3_I16::operator ==(const algo::strptr &rhs) const {
6127 return algo::LspaceStr3_I16_EqStrptr(const_cast<algo::LspaceStr3_I16&>(*this),rhs);
6128}
6129inline algo::LspaceStr3_I16::LspaceStr3_I16() {
6130 algo::LspaceStr3_I16_Init(*this);
6131}
6132
6133
6134// --- algo.LspaceStr3_I16.ch.Getary
6135// Access string as array of chars
6136inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr3_I16& parent) {
6137 int len = ch_N(parent);
6138 algo::aryptr<char> ret((char*)parent.ch, len);
6139 ret.elems += 3 - len;
6140 return ret;
6141}
6142
6143// --- algo.LspaceStr3_I16.ch.HashStrptr
6144inline u32 algo::LspaceStr3_I16_Hash(u32 prev, const algo::strptr &str) {
6145 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6146}
6147
6148// --- algo.LspaceStr3_I16.ch.Init
6149inline void algo::ch_Init(algo::LspaceStr3_I16 &parent) {
6150 memset(parent.ch, ' ', 3);
6151}
6152
6153// --- algo.LspaceStr3_I16.ch.Max
6154// always return constant 3
6155inline int algo::ch_Max(algo::LspaceStr3_I16& parent) {
6156 (void)parent;
6157 return 3;
6158}
6159
6160// --- algo.LspaceStr3_I16.ch.N
6161inline int algo::ch_N(const algo::LspaceStr3_I16& parent) {
6162 u64 ret;
6163 ret = 0;
6164 while (ret<3 && parent.ch[ret]==u8(' ')) {
6165 ret++;
6166 }
6167 ret = 3 - ret;
6168 return int(ret);
6169}
6170
6171// --- algo.LspaceStr3_I16.ch.AssignStrptr
6172// Copy from strptr (operator=)
6173inline void algo::LspaceStr3_I16::operator =(const algo::strptr &str) {
6174 ch_SetStrptr(*this, str);
6175}
6176
6177// --- algo.LspaceStr3_I16.ch.Set
6178// Copy from same type
6179// Copy value from RHS.
6180inline void algo::LspaceStr3_I16::operator =(const algo::LspaceStr3_I16& parent) {
6181 memcpy(ch, parent.ch, 3);
6182}
6183
6184// --- algo.LspaceStr3_I16.ch.Ctor
6185inline algo::LspaceStr3_I16::LspaceStr3_I16(const algo::LspaceStr3_I16 &rhs) {
6186 operator =(rhs);
6187}
6188
6189// --- algo.LspaceStr3_I16.ch.CtorStrptr
6190inline algo::LspaceStr3_I16::LspaceStr3_I16(const algo::strptr &rhs) {
6191 ch_SetStrptr(*this, rhs);
6192}
6193
6194// --- algo.LspaceStr3_I16.ch.Cast
6195inline algo::LspaceStr3_I16::operator algo::strptr () const {
6196 return ch_Getary(*this);
6197}
6198
6199// --- algo.LspaceStr3_I16..Cmp
6200inline i32 algo::LspaceStr3_I16_Cmp(algo::LspaceStr3_I16& lhs, algo::LspaceStr3_I16& rhs) {
6201 i32 retval = 0;
6202 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6203 return retval;
6204}
6205
6206// --- algo.LspaceStr3_I16..Init
6207// Set all fields to initial values.
6208inline void algo::LspaceStr3_I16_Init(algo::LspaceStr3_I16& parent) {
6209 memset(parent.ch, ' ', 3);
6210}
6211
6212// --- algo.LspaceStr3_I16..Eq
6213inline bool algo::LspaceStr3_I16_Eq(algo::LspaceStr3_I16& lhs, algo::LspaceStr3_I16& rhs) {
6214 bool retval = true;
6215 retval = retval
6216 &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
6217 &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
6218 return retval;
6219}
6220
6221// --- algo.LspaceStr3_I16..EqStrptr
6222inline bool algo::LspaceStr3_I16_EqStrptr(const algo::LspaceStr3_I16& lhs, const algo::strptr& rhs) {
6223 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6224}
6225
6226inline bool algo::LspaceStr4::operator ==(const algo::LspaceStr4 &rhs) const {
6227 return algo::LspaceStr4_Eq(const_cast<algo::LspaceStr4&>(*this),const_cast<algo::LspaceStr4&>(rhs));
6228}
6229
6230inline bool algo::LspaceStr4::operator !=(const algo::LspaceStr4 &rhs) const {
6231 return !algo::LspaceStr4_Eq(const_cast<algo::LspaceStr4&>(*this),const_cast<algo::LspaceStr4&>(rhs));
6232}
6233
6234inline bool algo::LspaceStr4::operator ==(const algo::strptr &rhs) const {
6235 return algo::LspaceStr4_EqStrptr(const_cast<algo::LspaceStr4&>(*this),rhs);
6236}
6237inline algo::LspaceStr4::LspaceStr4() {
6238 algo::LspaceStr4_Init(*this);
6239}
6240
6241
6242// --- algo.LspaceStr4.ch.Getary
6243// Access string as array of chars
6244inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr4& parent) {
6245 int len = ch_N(parent);
6246 algo::aryptr<char> ret((char*)parent.ch, len);
6247 ret.elems += 4 - len;
6248 return ret;
6249}
6250
6251// --- algo.LspaceStr4.ch.HashStrptr
6252inline u32 algo::LspaceStr4_Hash(u32 prev, const algo::strptr &str) {
6253 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6254}
6255
6256// --- algo.LspaceStr4.ch.Init
6257inline void algo::ch_Init(algo::LspaceStr4 &parent) {
6258 memset(parent.ch, ' ', 4);
6259}
6260
6261// --- algo.LspaceStr4.ch.Max
6262// always return constant 4
6263inline int algo::ch_Max(algo::LspaceStr4& parent) {
6264 (void)parent;
6265 return 4;
6266}
6267
6268// --- algo.LspaceStr4.ch.N
6269inline int algo::ch_N(const algo::LspaceStr4& parent) {
6270 u64 ret;
6271 ret = 0;
6272 while (ret<4 && parent.ch[ret]==u8(' ')) {
6273 ret++;
6274 }
6275 ret = 4 - ret;
6276 return int(ret);
6277}
6278
6279// --- algo.LspaceStr4.ch.AssignStrptr
6280// Copy from strptr (operator=)
6281inline void algo::LspaceStr4::operator =(const algo::strptr &str) {
6282 ch_SetStrptr(*this, str);
6283}
6284
6285// --- algo.LspaceStr4.ch.Set
6286// Copy from same type
6287// Copy value from RHS.
6288inline void algo::LspaceStr4::operator =(const algo::LspaceStr4& parent) {
6289 memcpy(ch, parent.ch, 4);
6290}
6291
6292// --- algo.LspaceStr4.ch.Ctor
6293inline algo::LspaceStr4::LspaceStr4(const algo::LspaceStr4 &rhs) {
6294 operator =(rhs);
6295}
6296
6297// --- algo.LspaceStr4.ch.CtorStrptr
6298inline algo::LspaceStr4::LspaceStr4(const algo::strptr &rhs) {
6299 ch_SetStrptr(*this, rhs);
6300}
6301
6302// --- algo.LspaceStr4.ch.Cast
6303inline algo::LspaceStr4::operator algo::strptr () const {
6304 return ch_Getary(*this);
6305}
6306
6307// --- algo.LspaceStr4..Cmp
6308inline i32 algo::LspaceStr4_Cmp(algo::LspaceStr4& lhs, algo::LspaceStr4& rhs) {
6309 i32 retval = 0;
6310 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6311 return retval;
6312}
6313
6314// --- algo.LspaceStr4..Init
6315// Set all fields to initial values.
6316inline void algo::LspaceStr4_Init(algo::LspaceStr4& parent) {
6317 memset(parent.ch, ' ', 4);
6318}
6319
6320// --- algo.LspaceStr4..Eq
6321inline bool algo::LspaceStr4_Eq(algo::LspaceStr4& lhs, algo::LspaceStr4& rhs) {
6322 bool retval = true;
6323 retval = retval
6324 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0);
6325 return retval;
6326}
6327
6328// --- algo.LspaceStr4..EqStrptr
6329inline bool algo::LspaceStr4_EqStrptr(const algo::LspaceStr4& lhs, const algo::strptr& rhs) {
6330 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6331}
6332
6333inline bool algo::LspaceStr5::operator ==(const algo::LspaceStr5 &rhs) const {
6334 return algo::LspaceStr5_Eq(const_cast<algo::LspaceStr5&>(*this),const_cast<algo::LspaceStr5&>(rhs));
6335}
6336
6337inline bool algo::LspaceStr5::operator !=(const algo::LspaceStr5 &rhs) const {
6338 return !algo::LspaceStr5_Eq(const_cast<algo::LspaceStr5&>(*this),const_cast<algo::LspaceStr5&>(rhs));
6339}
6340
6341inline bool algo::LspaceStr5::operator ==(const algo::strptr &rhs) const {
6342 return algo::LspaceStr5_EqStrptr(const_cast<algo::LspaceStr5&>(*this),rhs);
6343}
6344inline algo::LspaceStr5::LspaceStr5() {
6345 algo::LspaceStr5_Init(*this);
6346}
6347
6348
6349// --- algo.LspaceStr5.ch.Getary
6350// Access string as array of chars
6351inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr5& parent) {
6352 int len = ch_N(parent);
6353 algo::aryptr<char> ret((char*)parent.ch, len);
6354 ret.elems += 5 - len;
6355 return ret;
6356}
6357
6358// --- algo.LspaceStr5.ch.HashStrptr
6359inline u32 algo::LspaceStr5_Hash(u32 prev, const algo::strptr &str) {
6360 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6361}
6362
6363// --- algo.LspaceStr5.ch.Init
6364inline void algo::ch_Init(algo::LspaceStr5 &parent) {
6365 memset(parent.ch, ' ', 5);
6366}
6367
6368// --- algo.LspaceStr5.ch.Max
6369// always return constant 5
6370inline int algo::ch_Max(algo::LspaceStr5& parent) {
6371 (void)parent;
6372 return 5;
6373}
6374
6375// --- algo.LspaceStr5.ch.N
6376inline int algo::ch_N(const algo::LspaceStr5& parent) {
6377 u64 ret;
6378 ret = 0;
6379 while (ret<5 && parent.ch[ret]==u8(' ')) {
6380 ret++;
6381 }
6382 ret = 5 - ret;
6383 return int(ret);
6384}
6385
6386// --- algo.LspaceStr5.ch.AssignStrptr
6387// Copy from strptr (operator=)
6388inline void algo::LspaceStr5::operator =(const algo::strptr &str) {
6389 ch_SetStrptr(*this, str);
6390}
6391
6392// --- algo.LspaceStr5.ch.Set
6393// Copy from same type
6394// Copy value from RHS.
6395inline void algo::LspaceStr5::operator =(const algo::LspaceStr5& parent) {
6396 memcpy(ch, parent.ch, 5);
6397}
6398
6399// --- algo.LspaceStr5.ch.Ctor
6400inline algo::LspaceStr5::LspaceStr5(const algo::LspaceStr5 &rhs) {
6401 operator =(rhs);
6402}
6403
6404// --- algo.LspaceStr5.ch.CtorStrptr
6405inline algo::LspaceStr5::LspaceStr5(const algo::strptr &rhs) {
6406 ch_SetStrptr(*this, rhs);
6407}
6408
6409// --- algo.LspaceStr5.ch.Cast
6410inline algo::LspaceStr5::operator algo::strptr () const {
6411 return ch_Getary(*this);
6412}
6413
6414// --- algo.LspaceStr5..Cmp
6415inline i32 algo::LspaceStr5_Cmp(algo::LspaceStr5& lhs, algo::LspaceStr5& rhs) {
6416 i32 retval = 0;
6417 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6418 return retval;
6419}
6420
6421// --- algo.LspaceStr5..Init
6422// Set all fields to initial values.
6423inline void algo::LspaceStr5_Init(algo::LspaceStr5& parent) {
6424 memset(parent.ch, ' ', 5);
6425}
6426
6427// --- algo.LspaceStr5..Eq
6428inline bool algo::LspaceStr5_Eq(algo::LspaceStr5& lhs, algo::LspaceStr5& rhs) {
6429 bool retval = true;
6430 retval = retval
6431 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
6432 &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
6433 return retval;
6434}
6435
6436// --- algo.LspaceStr5..EqStrptr
6437inline bool algo::LspaceStr5_EqStrptr(const algo::LspaceStr5& lhs, const algo::strptr& rhs) {
6438 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6439}
6440
6441inline bool algo::LspaceStr5_I16::operator ==(const algo::LspaceStr5_I16 &rhs) const {
6442 return algo::LspaceStr5_I16_Eq(const_cast<algo::LspaceStr5_I16&>(*this),const_cast<algo::LspaceStr5_I16&>(rhs));
6443}
6444
6445inline bool algo::LspaceStr5_I16::operator !=(const algo::LspaceStr5_I16 &rhs) const {
6446 return !algo::LspaceStr5_I16_Eq(const_cast<algo::LspaceStr5_I16&>(*this),const_cast<algo::LspaceStr5_I16&>(rhs));
6447}
6448
6449inline bool algo::LspaceStr5_I16::operator ==(const algo::strptr &rhs) const {
6450 return algo::LspaceStr5_I16_EqStrptr(const_cast<algo::LspaceStr5_I16&>(*this),rhs);
6451}
6452inline algo::LspaceStr5_I16::LspaceStr5_I16() {
6453 algo::LspaceStr5_I16_Init(*this);
6454}
6455
6456
6457// --- algo.LspaceStr5_I16.ch.Getary
6458// Access string as array of chars
6459inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr5_I16& parent) {
6460 int len = ch_N(parent);
6461 algo::aryptr<char> ret((char*)parent.ch, len);
6462 ret.elems += 5 - len;
6463 return ret;
6464}
6465
6466// --- algo.LspaceStr5_I16.ch.HashStrptr
6467inline u32 algo::LspaceStr5_I16_Hash(u32 prev, const algo::strptr &str) {
6468 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6469}
6470
6471// --- algo.LspaceStr5_I16.ch.Init
6472inline void algo::ch_Init(algo::LspaceStr5_I16 &parent) {
6473 memset(parent.ch, ' ', 5);
6474}
6475
6476// --- algo.LspaceStr5_I16.ch.Max
6477// always return constant 5
6478inline int algo::ch_Max(algo::LspaceStr5_I16& parent) {
6479 (void)parent;
6480 return 5;
6481}
6482
6483// --- algo.LspaceStr5_I16.ch.N
6484inline int algo::ch_N(const algo::LspaceStr5_I16& parent) {
6485 u64 ret;
6486 ret = 0;
6487 while (ret<5 && parent.ch[ret]==u8(' ')) {
6488 ret++;
6489 }
6490 ret = 5 - ret;
6491 return int(ret);
6492}
6493
6494// --- algo.LspaceStr5_I16.ch.AssignStrptr
6495// Copy from strptr (operator=)
6496inline void algo::LspaceStr5_I16::operator =(const algo::strptr &str) {
6497 ch_SetStrptr(*this, str);
6498}
6499
6500// --- algo.LspaceStr5_I16.ch.Set
6501// Copy from same type
6502// Copy value from RHS.
6503inline void algo::LspaceStr5_I16::operator =(const algo::LspaceStr5_I16& parent) {
6504 memcpy(ch, parent.ch, 5);
6505}
6506
6507// --- algo.LspaceStr5_I16.ch.Ctor
6508inline algo::LspaceStr5_I16::LspaceStr5_I16(const algo::LspaceStr5_I16 &rhs) {
6509 operator =(rhs);
6510}
6511
6512// --- algo.LspaceStr5_I16.ch.CtorStrptr
6513inline algo::LspaceStr5_I16::LspaceStr5_I16(const algo::strptr &rhs) {
6514 ch_SetStrptr(*this, rhs);
6515}
6516
6517// --- algo.LspaceStr5_I16.ch.Cast
6518inline algo::LspaceStr5_I16::operator algo::strptr () const {
6519 return ch_Getary(*this);
6520}
6521
6522// --- algo.LspaceStr5_I16..Cmp
6523inline i32 algo::LspaceStr5_I16_Cmp(algo::LspaceStr5_I16& lhs, algo::LspaceStr5_I16& rhs) {
6524 i32 retval = 0;
6525 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6526 return retval;
6527}
6528
6529// --- algo.LspaceStr5_I16..Init
6530// Set all fields to initial values.
6531inline void algo::LspaceStr5_I16_Init(algo::LspaceStr5_I16& parent) {
6532 memset(parent.ch, ' ', 5);
6533}
6534
6535// --- algo.LspaceStr5_I16..Eq
6536inline bool algo::LspaceStr5_I16_Eq(algo::LspaceStr5_I16& lhs, algo::LspaceStr5_I16& rhs) {
6537 bool retval = true;
6538 retval = retval
6539 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
6540 &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
6541 return retval;
6542}
6543
6544// --- algo.LspaceStr5_I16..EqStrptr
6545inline bool algo::LspaceStr5_I16_EqStrptr(const algo::LspaceStr5_I16& lhs, const algo::strptr& rhs) {
6546 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6547}
6548
6549inline bool algo::LspaceStr6::operator ==(const algo::LspaceStr6 &rhs) const {
6550 return algo::LspaceStr6_Eq(const_cast<algo::LspaceStr6&>(*this),const_cast<algo::LspaceStr6&>(rhs));
6551}
6552
6553inline bool algo::LspaceStr6::operator !=(const algo::LspaceStr6 &rhs) const {
6554 return !algo::LspaceStr6_Eq(const_cast<algo::LspaceStr6&>(*this),const_cast<algo::LspaceStr6&>(rhs));
6555}
6556
6557inline bool algo::LspaceStr6::operator ==(const algo::strptr &rhs) const {
6558 return algo::LspaceStr6_EqStrptr(const_cast<algo::LspaceStr6&>(*this),rhs);
6559}
6560inline algo::LspaceStr6::LspaceStr6() {
6561 algo::LspaceStr6_Init(*this);
6562}
6563
6564
6565// --- algo.LspaceStr6.ch.Getary
6566// Access string as array of chars
6567inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr6& parent) {
6568 int len = ch_N(parent);
6569 algo::aryptr<char> ret((char*)parent.ch, len);
6570 ret.elems += 6 - len;
6571 return ret;
6572}
6573
6574// --- algo.LspaceStr6.ch.HashStrptr
6575inline u32 algo::LspaceStr6_Hash(u32 prev, const algo::strptr &str) {
6576 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6577}
6578
6579// --- algo.LspaceStr6.ch.Init
6580inline void algo::ch_Init(algo::LspaceStr6 &parent) {
6581 memset(parent.ch, ' ', 6);
6582}
6583
6584// --- algo.LspaceStr6.ch.Max
6585// always return constant 6
6586inline int algo::ch_Max(algo::LspaceStr6& parent) {
6587 (void)parent;
6588 return 6;
6589}
6590
6591// --- algo.LspaceStr6.ch.N
6592inline int algo::ch_N(const algo::LspaceStr6& parent) {
6593 u64 ret;
6594 ret = 0;
6595 while (ret<6 && parent.ch[ret]==u8(' ')) {
6596 ret++;
6597 }
6598 ret = 6 - ret;
6599 return int(ret);
6600}
6601
6602// --- algo.LspaceStr6.ch.AssignStrptr
6603// Copy from strptr (operator=)
6604inline void algo::LspaceStr6::operator =(const algo::strptr &str) {
6605 ch_SetStrptr(*this, str);
6606}
6607
6608// --- algo.LspaceStr6.ch.Set
6609// Copy from same type
6610// Copy value from RHS.
6611inline void algo::LspaceStr6::operator =(const algo::LspaceStr6& parent) {
6612 memcpy(ch, parent.ch, 6);
6613}
6614
6615// --- algo.LspaceStr6.ch.Ctor
6616inline algo::LspaceStr6::LspaceStr6(const algo::LspaceStr6 &rhs) {
6617 operator =(rhs);
6618}
6619
6620// --- algo.LspaceStr6.ch.CtorStrptr
6621inline algo::LspaceStr6::LspaceStr6(const algo::strptr &rhs) {
6622 ch_SetStrptr(*this, rhs);
6623}
6624
6625// --- algo.LspaceStr6.ch.Cast
6626inline algo::LspaceStr6::operator algo::strptr () const {
6627 return ch_Getary(*this);
6628}
6629
6630// --- algo.LspaceStr6..Cmp
6631inline i32 algo::LspaceStr6_Cmp(algo::LspaceStr6& lhs, algo::LspaceStr6& rhs) {
6632 i32 retval = 0;
6633 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6634 return retval;
6635}
6636
6637// --- algo.LspaceStr6..Init
6638// Set all fields to initial values.
6639inline void algo::LspaceStr6_Init(algo::LspaceStr6& parent) {
6640 memset(parent.ch, ' ', 6);
6641}
6642
6643// --- algo.LspaceStr6..Eq
6644inline bool algo::LspaceStr6_Eq(algo::LspaceStr6& lhs, algo::LspaceStr6& rhs) {
6645 bool retval = true;
6646 retval = retval
6647 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
6648 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
6649 return retval;
6650}
6651
6652// --- algo.LspaceStr6..EqStrptr
6653inline bool algo::LspaceStr6_EqStrptr(const algo::LspaceStr6& lhs, const algo::strptr& rhs) {
6654 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6655}
6656
6657inline bool algo::LspaceStr6_U32::operator ==(const algo::LspaceStr6_U32 &rhs) const {
6658 return algo::LspaceStr6_U32_Eq(const_cast<algo::LspaceStr6_U32&>(*this),const_cast<algo::LspaceStr6_U32&>(rhs));
6659}
6660
6661inline bool algo::LspaceStr6_U32::operator !=(const algo::LspaceStr6_U32 &rhs) const {
6662 return !algo::LspaceStr6_U32_Eq(const_cast<algo::LspaceStr6_U32&>(*this),const_cast<algo::LspaceStr6_U32&>(rhs));
6663}
6664
6665inline bool algo::LspaceStr6_U32::operator ==(const algo::strptr &rhs) const {
6666 return algo::LspaceStr6_U32_EqStrptr(const_cast<algo::LspaceStr6_U32&>(*this),rhs);
6667}
6668inline algo::LspaceStr6_U32::LspaceStr6_U32() {
6669 algo::LspaceStr6_U32_Init(*this);
6670}
6671
6672
6673// --- algo.LspaceStr6_U32.ch.Getary
6674// Access string as array of chars
6675inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr6_U32& parent) {
6676 int len = ch_N(parent);
6677 algo::aryptr<char> ret((char*)parent.ch, len);
6678 ret.elems += 6 - len;
6679 return ret;
6680}
6681
6682// --- algo.LspaceStr6_U32.ch.HashStrptr
6683inline u32 algo::LspaceStr6_U32_Hash(u32 prev, const algo::strptr &str) {
6684 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6685}
6686
6687// --- algo.LspaceStr6_U32.ch.Init
6688inline void algo::ch_Init(algo::LspaceStr6_U32 &parent) {
6689 memset(parent.ch, ' ', 6);
6690}
6691
6692// --- algo.LspaceStr6_U32.ch.Max
6693// always return constant 6
6694inline int algo::ch_Max(algo::LspaceStr6_U32& parent) {
6695 (void)parent;
6696 return 6;
6697}
6698
6699// --- algo.LspaceStr6_U32.ch.N
6700inline int algo::ch_N(const algo::LspaceStr6_U32& parent) {
6701 u64 ret;
6702 ret = 0;
6703 while (ret<6 && parent.ch[ret]==u8(' ')) {
6704 ret++;
6705 }
6706 ret = 6 - ret;
6707 return int(ret);
6708}
6709
6710// --- algo.LspaceStr6_U32.ch.AssignStrptr
6711// Copy from strptr (operator=)
6712inline void algo::LspaceStr6_U32::operator =(const algo::strptr &str) {
6713 ch_SetStrptr(*this, str);
6714}
6715
6716// --- algo.LspaceStr6_U32.ch.Set
6717// Copy from same type
6718// Copy value from RHS.
6719inline void algo::LspaceStr6_U32::operator =(const algo::LspaceStr6_U32& parent) {
6720 memcpy(ch, parent.ch, 6);
6721}
6722
6723// --- algo.LspaceStr6_U32.ch.Ctor
6724inline algo::LspaceStr6_U32::LspaceStr6_U32(const algo::LspaceStr6_U32 &rhs) {
6725 operator =(rhs);
6726}
6727
6728// --- algo.LspaceStr6_U32.ch.CtorStrptr
6729inline algo::LspaceStr6_U32::LspaceStr6_U32(const algo::strptr &rhs) {
6730 ch_SetStrptr(*this, rhs);
6731}
6732
6733// --- algo.LspaceStr6_U32.ch.Cast
6734inline algo::LspaceStr6_U32::operator algo::strptr () const {
6735 return ch_Getary(*this);
6736}
6737
6738// --- algo.LspaceStr6_U32..Cmp
6739inline i32 algo::LspaceStr6_U32_Cmp(algo::LspaceStr6_U32& lhs, algo::LspaceStr6_U32& rhs) {
6740 i32 retval = 0;
6741 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6742 return retval;
6743}
6744
6745// --- algo.LspaceStr6_U32..Init
6746// Set all fields to initial values.
6747inline void algo::LspaceStr6_U32_Init(algo::LspaceStr6_U32& parent) {
6748 memset(parent.ch, ' ', 6);
6749}
6750
6751// --- algo.LspaceStr6_U32..Eq
6752inline bool algo::LspaceStr6_U32_Eq(algo::LspaceStr6_U32& lhs, algo::LspaceStr6_U32& rhs) {
6753 bool retval = true;
6754 retval = retval
6755 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
6756 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
6757 return retval;
6758}
6759
6760// --- algo.LspaceStr6_U32..EqStrptr
6761inline bool algo::LspaceStr6_U32_EqStrptr(const algo::LspaceStr6_U32& lhs, const algo::strptr& rhs) {
6762 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6763}
6764
6765inline bool algo::LspaceStr7_I32_Base36::operator ==(const algo::LspaceStr7_I32_Base36 &rhs) const {
6766 return algo::LspaceStr7_I32_Base36_Eq(const_cast<algo::LspaceStr7_I32_Base36&>(*this),const_cast<algo::LspaceStr7_I32_Base36&>(rhs));
6767}
6768
6769inline bool algo::LspaceStr7_I32_Base36::operator !=(const algo::LspaceStr7_I32_Base36 &rhs) const {
6770 return !algo::LspaceStr7_I32_Base36_Eq(const_cast<algo::LspaceStr7_I32_Base36&>(*this),const_cast<algo::LspaceStr7_I32_Base36&>(rhs));
6771}
6772
6773inline bool algo::LspaceStr7_I32_Base36::operator ==(const algo::strptr &rhs) const {
6774 return algo::LspaceStr7_I32_Base36_EqStrptr(const_cast<algo::LspaceStr7_I32_Base36&>(*this),rhs);
6775}
6776inline algo::LspaceStr7_I32_Base36::LspaceStr7_I32_Base36() {
6777 algo::LspaceStr7_I32_Base36_Init(*this);
6778}
6779
6780
6781// --- algo.LspaceStr7_I32_Base36.ch.Getary
6782// Access string as array of chars
6783inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr7_I32_Base36& parent) {
6784 int len = ch_N(parent);
6785 algo::aryptr<char> ret((char*)parent.ch, len);
6786 ret.elems += 7 - len;
6787 return ret;
6788}
6789
6790// --- algo.LspaceStr7_I32_Base36.ch.HashStrptr
6791inline u32 algo::LspaceStr7_I32_Base36_Hash(u32 prev, const algo::strptr &str) {
6792 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6793}
6794
6795// --- algo.LspaceStr7_I32_Base36.ch.Init
6796inline void algo::ch_Init(algo::LspaceStr7_I32_Base36 &parent) {
6797 memset(parent.ch, ' ', 7);
6798}
6799
6800// --- algo.LspaceStr7_I32_Base36.ch.Max
6801// always return constant 7
6802inline int algo::ch_Max(algo::LspaceStr7_I32_Base36& parent) {
6803 (void)parent;
6804 return 7;
6805}
6806
6807// --- algo.LspaceStr7_I32_Base36.ch.N
6808inline int algo::ch_N(const algo::LspaceStr7_I32_Base36& parent) {
6809 u64 ret;
6810 ret = 0;
6811 while (ret<7 && parent.ch[ret]==u8(' ')) {
6812 ret++;
6813 }
6814 ret = 7 - ret;
6815 return int(ret);
6816}
6817
6818// --- algo.LspaceStr7_I32_Base36.ch.AssignStrptr
6819// Copy from strptr (operator=)
6820inline void algo::LspaceStr7_I32_Base36::operator =(const algo::strptr &str) {
6821 ch_SetStrptr(*this, str);
6822}
6823
6824// --- algo.LspaceStr7_I32_Base36.ch.Set
6825// Copy from same type
6826// Copy value from RHS.
6827inline void algo::LspaceStr7_I32_Base36::operator =(const algo::LspaceStr7_I32_Base36& parent) {
6828 memcpy(ch, parent.ch, 7);
6829}
6830
6831// --- algo.LspaceStr7_I32_Base36.ch.Ctor
6832inline algo::LspaceStr7_I32_Base36::LspaceStr7_I32_Base36(const algo::LspaceStr7_I32_Base36 &rhs) {
6833 operator =(rhs);
6834}
6835
6836// --- algo.LspaceStr7_I32_Base36.ch.CtorStrptr
6837inline algo::LspaceStr7_I32_Base36::LspaceStr7_I32_Base36(const algo::strptr &rhs) {
6838 ch_SetStrptr(*this, rhs);
6839}
6840
6841// --- algo.LspaceStr7_I32_Base36.ch.Cast
6842inline algo::LspaceStr7_I32_Base36::operator algo::strptr () const {
6843 return ch_Getary(*this);
6844}
6845
6846// --- algo.LspaceStr7_I32_Base36..Cmp
6847inline i32 algo::LspaceStr7_I32_Base36_Cmp(algo::LspaceStr7_I32_Base36& lhs, algo::LspaceStr7_I32_Base36& rhs) {
6848 i32 retval = 0;
6849 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6850 return retval;
6851}
6852
6853// --- algo.LspaceStr7_I32_Base36..Init
6854// Set all fields to initial values.
6855inline void algo::LspaceStr7_I32_Base36_Init(algo::LspaceStr7_I32_Base36& parent) {
6856 memset(parent.ch, ' ', 7);
6857}
6858
6859// --- algo.LspaceStr7_I32_Base36..Eq
6860inline bool algo::LspaceStr7_I32_Base36_Eq(algo::LspaceStr7_I32_Base36& lhs, algo::LspaceStr7_I32_Base36& rhs) {
6861 bool retval = true;
6862 retval = retval
6863 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
6864 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
6865 &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
6866 return retval;
6867}
6868
6869// --- algo.LspaceStr7_I32_Base36..EqStrptr
6870inline bool algo::LspaceStr7_I32_Base36_EqStrptr(const algo::LspaceStr7_I32_Base36& lhs, const algo::strptr& rhs) {
6871 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6872}
6873
6874inline bool algo::LspaceStr8::operator ==(const algo::LspaceStr8 &rhs) const {
6875 return algo::LspaceStr8_Eq(const_cast<algo::LspaceStr8&>(*this),const_cast<algo::LspaceStr8&>(rhs));
6876}
6877
6878inline bool algo::LspaceStr8::operator !=(const algo::LspaceStr8 &rhs) const {
6879 return !algo::LspaceStr8_Eq(const_cast<algo::LspaceStr8&>(*this),const_cast<algo::LspaceStr8&>(rhs));
6880}
6881
6882inline bool algo::LspaceStr8::operator ==(const algo::strptr &rhs) const {
6883 return algo::LspaceStr8_EqStrptr(const_cast<algo::LspaceStr8&>(*this),rhs);
6884}
6885inline algo::LspaceStr8::LspaceStr8() {
6886 algo::LspaceStr8_Init(*this);
6887}
6888
6889
6890// --- algo.LspaceStr8.ch.Getary
6891// Access string as array of chars
6892inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr8& parent) {
6893 int len = ch_N(parent);
6894 algo::aryptr<char> ret((char*)parent.ch, len);
6895 ret.elems += 8 - len;
6896 return ret;
6897}
6898
6899// --- algo.LspaceStr8.ch.HashStrptr
6900inline u32 algo::LspaceStr8_Hash(u32 prev, const algo::strptr &str) {
6901 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
6902}
6903
6904// --- algo.LspaceStr8.ch.Init
6905inline void algo::ch_Init(algo::LspaceStr8 &parent) {
6906 memset(parent.ch, ' ', 8);
6907}
6908
6909// --- algo.LspaceStr8.ch.Max
6910// always return constant 8
6911inline int algo::ch_Max(algo::LspaceStr8& parent) {
6912 (void)parent;
6913 return 8;
6914}
6915
6916// --- algo.LspaceStr8.ch.N
6917inline int algo::ch_N(const algo::LspaceStr8& parent) {
6918 u64 ret;
6919 ret = 0;
6920 while (ret<8 && parent.ch[ret]==u8(' ')) {
6921 ret++;
6922 }
6923 ret = 8 - ret;
6924 return int(ret);
6925}
6926
6927// --- algo.LspaceStr8.ch.AssignStrptr
6928// Copy from strptr (operator=)
6929inline void algo::LspaceStr8::operator =(const algo::strptr &str) {
6930 ch_SetStrptr(*this, str);
6931}
6932
6933// --- algo.LspaceStr8.ch.Set
6934// Copy from same type
6935// Copy value from RHS.
6936inline void algo::LspaceStr8::operator =(const algo::LspaceStr8& parent) {
6937 memcpy(ch, parent.ch, 8);
6938}
6939
6940// --- algo.LspaceStr8.ch.Ctor
6941inline algo::LspaceStr8::LspaceStr8(const algo::LspaceStr8 &rhs) {
6942 operator =(rhs);
6943}
6944
6945// --- algo.LspaceStr8.ch.CtorStrptr
6946inline algo::LspaceStr8::LspaceStr8(const algo::strptr &rhs) {
6947 ch_SetStrptr(*this, rhs);
6948}
6949
6950// --- algo.LspaceStr8.ch.Cast
6951inline algo::LspaceStr8::operator algo::strptr () const {
6952 return ch_Getary(*this);
6953}
6954
6955// --- algo.LspaceStr8..Cmp
6956inline i32 algo::LspaceStr8_Cmp(algo::LspaceStr8& lhs, algo::LspaceStr8& rhs) {
6957 i32 retval = 0;
6958 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
6959 return retval;
6960}
6961
6962// --- algo.LspaceStr8..Init
6963// Set all fields to initial values.
6964inline void algo::LspaceStr8_Init(algo::LspaceStr8& parent) {
6965 memset(parent.ch, ' ', 8);
6966}
6967
6968// --- algo.LspaceStr8..Eq
6969inline bool algo::LspaceStr8_Eq(algo::LspaceStr8& lhs, algo::LspaceStr8& rhs) {
6970 bool retval = true;
6971 retval = retval
6972 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
6973 return retval;
6974}
6975
6976// --- algo.LspaceStr8..EqStrptr
6977inline bool algo::LspaceStr8_EqStrptr(const algo::LspaceStr8& lhs, const algo::strptr& rhs) {
6978 return algo::strptr_Eq(ch_Getary(lhs), rhs);
6979}
6980
6981inline bool algo::LspaceStr9::operator ==(const algo::LspaceStr9 &rhs) const {
6982 return algo::LspaceStr9_Eq(const_cast<algo::LspaceStr9&>(*this),const_cast<algo::LspaceStr9&>(rhs));
6983}
6984
6985inline bool algo::LspaceStr9::operator !=(const algo::LspaceStr9 &rhs) const {
6986 return !algo::LspaceStr9_Eq(const_cast<algo::LspaceStr9&>(*this),const_cast<algo::LspaceStr9&>(rhs));
6987}
6988
6989inline bool algo::LspaceStr9::operator ==(const algo::strptr &rhs) const {
6990 return algo::LspaceStr9_EqStrptr(const_cast<algo::LspaceStr9&>(*this),rhs);
6991}
6992inline algo::LspaceStr9::LspaceStr9() {
6993 algo::LspaceStr9_Init(*this);
6994}
6995
6996
6997// --- algo.LspaceStr9.ch.Getary
6998// Access string as array of chars
6999inline algo::aryptr<char> algo::ch_Getary(const algo::LspaceStr9& parent) {
7000 int len = ch_N(parent);
7001 algo::aryptr<char> ret((char*)parent.ch, len);
7002 ret.elems += 9 - len;
7003 return ret;
7004}
7005
7006// --- algo.LspaceStr9.ch.HashStrptr
7007inline u32 algo::LspaceStr9_Hash(u32 prev, const algo::strptr &str) {
7008 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
7009}
7010
7011// --- algo.LspaceStr9.ch.Init
7012inline void algo::ch_Init(algo::LspaceStr9 &parent) {
7013 memset(parent.ch, ' ', 9);
7014}
7015
7016// --- algo.LspaceStr9.ch.Max
7017// always return constant 9
7018inline int algo::ch_Max(algo::LspaceStr9& parent) {
7019 (void)parent;
7020 return 9;
7021}
7022
7023// --- algo.LspaceStr9.ch.N
7024inline int algo::ch_N(const algo::LspaceStr9& parent) {
7025 u64 ret;
7026 ret = 0;
7027 while (ret<9 && parent.ch[ret]==u8(' ')) {
7028 ret++;
7029 }
7030 ret = 9 - ret;
7031 return int(ret);
7032}
7033
7034// --- algo.LspaceStr9.ch.AssignStrptr
7035// Copy from strptr (operator=)
7036inline void algo::LspaceStr9::operator =(const algo::strptr &str) {
7037 ch_SetStrptr(*this, str);
7038}
7039
7040// --- algo.LspaceStr9.ch.Set
7041// Copy from same type
7042// Copy value from RHS.
7043inline void algo::LspaceStr9::operator =(const algo::LspaceStr9& parent) {
7044 memcpy(ch, parent.ch, 9);
7045}
7046
7047// --- algo.LspaceStr9.ch.Ctor
7048inline algo::LspaceStr9::LspaceStr9(const algo::LspaceStr9 &rhs) {
7049 operator =(rhs);
7050}
7051
7052// --- algo.LspaceStr9.ch.CtorStrptr
7053inline algo::LspaceStr9::LspaceStr9(const algo::strptr &rhs) {
7054 ch_SetStrptr(*this, rhs);
7055}
7056
7057// --- algo.LspaceStr9.ch.Cast
7058inline algo::LspaceStr9::operator algo::strptr () const {
7059 return ch_Getary(*this);
7060}
7061
7062// --- algo.LspaceStr9..Cmp
7063inline i32 algo::LspaceStr9_Cmp(algo::LspaceStr9& lhs, algo::LspaceStr9& rhs) {
7064 i32 retval = 0;
7065 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
7066 return retval;
7067}
7068
7069// --- algo.LspaceStr9..Init
7070// Set all fields to initial values.
7071inline void algo::LspaceStr9_Init(algo::LspaceStr9& parent) {
7072 memset(parent.ch, ' ', 9);
7073}
7074
7075// --- algo.LspaceStr9..Eq
7076inline bool algo::LspaceStr9_Eq(algo::LspaceStr9& lhs, algo::LspaceStr9& rhs) {
7077 bool retval = true;
7078 retval = retval
7079 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
7080 &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
7081 return retval;
7082}
7083
7084// --- algo.LspaceStr9..EqStrptr
7085inline bool algo::LspaceStr9_EqStrptr(const algo::LspaceStr9& lhs, const algo::strptr& rhs) {
7086 return algo::strptr_Eq(ch_Getary(lhs), rhs);
7087}
7088inline algo::Md5Digest::Md5Digest(algo::aryptr<u8 > in_value)
7089{
7090 value_Setary(*this, in_value);
7091}
7092inline algo::Md5Digest::Md5Digest() {
7093 algo::Md5Digest_Init(*this);
7094}
7095
7096
7097// --- algo.Md5Digest.value.Fill
7098// Set all elements of fixed array to value RHS
7099inline void algo::value_Fill(algo::Md5Digest& parent, const u8 &rhs) {
7100 for (int i = 0; i < 16; i++) {
7101 parent.value_elems[i] = rhs;
7102 }
7103}
7104
7105// --- algo.Md5Digest.value.Find
7106// Look up row by row id. Return NULL if out of range
7107inline u8* algo::value_Find(algo::Md5Digest& parent, u64 t) {
7108 u64 idx = t;
7109 u64 lim = 16;
7110 return idx < lim ? parent.value_elems + idx : NULL; // unsigned comparison with limit
7111}
7112
7113// --- algo.Md5Digest.value.Getary
7114// Access fixed array value as aryptr.
7115inline algo::aryptr<u8> algo::value_Getary(algo::Md5Digest& parent) {
7116 return algo::aryptr<u8>(parent.value_elems, 16);
7117}
7118
7119// --- algo.Md5Digest.value.Max
7120// Return max number of items in the array
7121inline i32 algo::value_Max(algo::Md5Digest& parent) {
7122 (void)parent;
7123 return 16;
7124}
7125
7126// --- algo.Md5Digest.value.N
7127// Return number of items in the array
7128inline i32 algo::value_N(const algo::Md5Digest& parent) {
7129 (void)parent;//only to avoid -Wunused-parameter
7130 return 16;
7131}
7132
7133// --- algo.Md5Digest.value.Setary
7134// Set contents of fixed array to RHS; Input length is trimmed as necessary
7135inline void algo::value_Setary(algo::Md5Digest& parent, const algo::aryptr<u8> &rhs) {
7136 int n = 16 < rhs.n_elems ? 16 : rhs.n_elems;
7137 for (int i = 0; i < n; i++) {
7138 parent.value_elems[i] = rhs[i];
7139 }
7140}
7141
7142// --- algo.Md5Digest.value.qFind
7143// 'quick' Access row by row id. No bounds checking in release.
7144inline u8& algo::value_qFind(algo::Md5Digest& parent, u64 t) {
7145 return parent.value_elems[u64(t)];
7146}
7147
7148// --- algo.Md5Digest.value_curs.Reset
7149// cursor points to valid item
7150inline void algo::Md5Digest_value_curs_Reset(Md5Digest_value_curs &curs, algo::Md5Digest &parent) {
7151 curs.parent = &parent;
7152 curs.index = 0;
7153}
7154
7155// --- algo.Md5Digest.value_curs.ValidQ
7156// cursor points to valid item
7157inline bool algo::Md5Digest_value_curs_ValidQ(Md5Digest_value_curs &curs) {
7158 return u64(curs.index) < u64(16);
7159}
7160
7161// --- algo.Md5Digest.value_curs.Next
7162// proceed to next item
7163inline void algo::Md5Digest_value_curs_Next(Md5Digest_value_curs &curs) {
7164 curs.index++;
7165}
7166
7167// --- algo.Md5Digest.value_curs.Access
7168// item access
7169inline u8& algo::Md5Digest_value_curs_Access(Md5Digest_value_curs &curs) {
7170 return value_qFind((*curs.parent), u64(curs.index));
7171}
7172
7173// --- algo.Md5Digest..Init
7174// Set all fields to initial values.
7175inline void algo::Md5Digest_Init(algo::Md5Digest& parent) {
7176 for (int i = 0; i < 16; i++) {
7177 parent.value_elems[i] = 0;
7178 }
7179}
7180inline algo::Month::Month(u32 in_value)
7181 : value(in_value)
7182{
7183}
7184inline algo::Month::Month(algo_MonthEnum arg) { this->value = u32(arg); }
7185inline algo::Month::Month() {
7186 algo::Month_Init(*this);
7187}
7188
7189
7190// --- algo.Month.value.GetEnum
7191// Get value of field as enum type
7192inline algo_MonthEnum algo::value_GetEnum(const algo::Month& parent) {
7193 return algo_MonthEnum(parent.value);
7194}
7195
7196// --- algo.Month.value.SetEnum
7197// Set value of field from enum type.
7198inline void algo::value_SetEnum(algo::Month& parent, algo_MonthEnum rhs) {
7199 parent.value = u32(rhs);
7200}
7201
7202// --- algo.Month.value.Cast
7203inline algo::Month::operator algo_MonthEnum () const {
7204 return algo_MonthEnum((*this).value);
7205}
7206
7207// --- algo.Month..Init
7208// Set all fields to initial values.
7209inline void algo::Month_Init(algo::Month& parent) {
7210 parent.value = u32(0);
7211}
7212inline algo::NumParseFlags::NumParseFlags(u32 in_value)
7213 : value(in_value)
7214{
7215}
7216inline algo::NumParseFlags::NumParseFlags(algo_NumParseFlagsEnum arg) { this->value = u32(arg); }
7217inline algo::NumParseFlags::NumParseFlags() {
7218 algo::NumParseFlags_Init(*this);
7219}
7220
7221
7222// --- algo.NumParseFlags.value.Cast
7223inline algo::NumParseFlags::operator algo_NumParseFlagsEnum () const {
7224 return algo_NumParseFlagsEnum((*this).value);
7225}
7226
7227// --- algo.NumParseFlags.err.Get
7228// Retrieve bitfield from value of field value
7229// 1 bits starting at bit 0.
7230inline bool algo::err_Get(const algo::NumParseFlags& parent) {
7231 return bool((parent.value >> 0) & 0x01);
7232}
7233
7234// --- algo.NumParseFlags.err.Set
7235// Set bitfield in value of field 'value'
7236// 1 bits starting at bit 0.
7237inline void algo::err_Set(algo::NumParseFlags& parent, bool rhs) {
7238 u32 t1 = u32(0x01) << 0;
7239 u32 t2 = (u32(rhs) & 0x01) << 0;
7240 parent.value = u32((parent.value & ~t1) | t2);
7241}
7242
7243// --- algo.NumParseFlags.ok.Get
7244// Retrieve bitfield from value of field value
7245// 1 bits starting at bit 1.
7246inline bool algo::ok_Get(const algo::NumParseFlags& parent) {
7247 return bool((parent.value >> 1) & 0x01);
7248}
7249
7250// --- algo.NumParseFlags.ok.Set
7251// Set bitfield in value of field 'value'
7252// 1 bits starting at bit 1.
7253inline void algo::ok_Set(algo::NumParseFlags& parent, bool rhs) {
7254 u32 t1 = u32(0x01) << 1;
7255 u32 t2 = (u32(rhs) & 0x01) << 1;
7256 parent.value = u32((parent.value & ~t1) | t2);
7257}
7258
7259// --- algo.NumParseFlags.neg.Get
7260// Retrieve bitfield from value of field value
7261// 1 bits starting at bit 2.
7262inline bool algo::neg_Get(const algo::NumParseFlags& parent) {
7263 return bool((parent.value >> 2) & 0x01);
7264}
7265
7266// --- algo.NumParseFlags.neg.Set
7267// Set bitfield in value of field 'value'
7268// 1 bits starting at bit 2.
7269inline void algo::neg_Set(algo::NumParseFlags& parent, bool rhs) {
7270 u32 t1 = u32(0x01) << 2;
7271 u32 t2 = (u32(rhs) & 0x01) << 2;
7272 parent.value = u32((parent.value & ~t1) | t2);
7273}
7274
7275// --- algo.NumParseFlags.overflow.Get
7276// Retrieve bitfield from value of field value
7277// 1 bits starting at bit 3.
7278inline bool algo::overflow_Get(const algo::NumParseFlags& parent) {
7279 return bool((parent.value >> 3) & 0x01);
7280}
7281
7282// --- algo.NumParseFlags.overflow.Set
7283// Set bitfield in value of field 'value'
7284// 1 bits starting at bit 3.
7285inline void algo::overflow_Set(algo::NumParseFlags& parent, bool rhs) {
7286 u32 t1 = u32(0x01) << 3;
7287 u32 t2 = (u32(rhs) & 0x01) << 3;
7288 parent.value = u32((parent.value & ~t1) | t2);
7289}
7290
7291// --- algo.NumParseFlags.hex.Get
7292// Retrieve bitfield from value of field value
7293// 1 bits starting at bit 4.
7294inline bool algo::hex_Get(const algo::NumParseFlags& parent) {
7295 return bool((parent.value >> 4) & 0x01);
7296}
7297
7298// --- algo.NumParseFlags.hex.Set
7299// Set bitfield in value of field 'value'
7300// 1 bits starting at bit 4.
7301inline void algo::hex_Set(algo::NumParseFlags& parent, bool rhs) {
7302 u32 t1 = u32(0x01) << 4;
7303 u32 t2 = (u32(rhs) & 0x01) << 4;
7304 parent.value = u32((parent.value & ~t1) | t2);
7305}
7306
7307// --- algo.NumParseFlags..Init
7308// Set all fields to initial values.
7309inline void algo::NumParseFlags_Init(algo::NumParseFlags& parent) {
7310 parent.value = u32(0);
7311}
7312
7313inline bool algo::RnullStr1::operator ==(const algo::RnullStr1 &rhs) const {
7314 return algo::RnullStr1_Eq(const_cast<algo::RnullStr1&>(*this),const_cast<algo::RnullStr1&>(rhs));
7315}
7316
7317inline bool algo::RnullStr1::operator !=(const algo::RnullStr1 &rhs) const {
7318 return !algo::RnullStr1_Eq(const_cast<algo::RnullStr1&>(*this),const_cast<algo::RnullStr1&>(rhs));
7319}
7320
7321inline bool algo::RnullStr1::operator ==(const algo::strptr &rhs) const {
7322 return algo::RnullStr1_EqStrptr(const_cast<algo::RnullStr1&>(*this),rhs);
7323}
7324
7325inline bool algo::RnullStr1::operator <(const algo::RnullStr1 &rhs) const {
7326 return algo::RnullStr1_Lt(const_cast<algo::RnullStr1&>(*this),const_cast<algo::RnullStr1&>(rhs));
7327}
7328
7329inline bool algo::RnullStr1::operator >(const algo::RnullStr1 &rhs) const {
7330 return rhs < *this;
7331}
7332
7333inline bool algo::RnullStr1::operator <=(const algo::RnullStr1 &rhs) const {
7334 return !(rhs < *this);
7335}
7336
7337inline bool algo::RnullStr1::operator >=(const algo::RnullStr1 &rhs) const {
7338 return !(*this < rhs);
7339}
7340inline algo::RnullStr1::RnullStr1() {
7341 algo::RnullStr1_Init(*this);
7342}
7343
7344
7345// --- algo.RnullStr1.ch.Getary
7346// Access string as array of chars
7347inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr1& parent) {
7348 int len = ch_N(parent);
7349 algo::aryptr<char> ret((char*)parent.ch, len);
7350 return ret;
7351}
7352
7353// --- algo.RnullStr1.ch.HashStrptr
7354inline u32 algo::RnullStr1_Hash(u32 prev, const algo::strptr &str) {
7355 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
7356}
7357
7358// --- algo.RnullStr1.ch.Init
7359inline void algo::ch_Init(algo::RnullStr1 &parent) {
7360 memset(parent.ch, 0, 1);
7361}
7362
7363// --- algo.RnullStr1.ch.Max
7364// always return constant 1
7365inline int algo::ch_Max(algo::RnullStr1& parent) {
7366 (void)parent;
7367 return 1;
7368}
7369
7370// --- algo.RnullStr1.ch.N
7371inline int algo::ch_N(const algo::RnullStr1& parent) {
7372 u64 ret;
7373 ret = 1;
7374 while (ret>0 && parent.ch[ret-1]==u8(0)) {
7375 ret--;
7376 }
7377 return int(ret);
7378}
7379
7380// --- algo.RnullStr1.ch.AssignStrptr
7381// Copy from strptr (operator=)
7382inline void algo::RnullStr1::operator =(const algo::strptr &str) {
7383 ch_SetStrptr(*this, str);
7384}
7385
7386// --- algo.RnullStr1.ch.Set
7387// Copy from same type
7388// Copy value from RHS.
7389inline void algo::RnullStr1::operator =(const algo::RnullStr1& parent) {
7390 memcpy(ch, parent.ch, 1);
7391}
7392
7393// --- algo.RnullStr1.ch.Ctor
7394inline algo::RnullStr1::RnullStr1(const algo::RnullStr1 &rhs) {
7395 operator =(rhs);
7396}
7397
7398// --- algo.RnullStr1.ch.CtorStrptr
7399inline algo::RnullStr1::RnullStr1(const algo::strptr &rhs) {
7400 ch_SetStrptr(*this, rhs);
7401}
7402
7403// --- algo.RnullStr1.ch.Cast
7404inline algo::RnullStr1::operator algo::strptr () const {
7405 return ch_Getary(*this);
7406}
7407
7408// --- algo.RnullStr1..Lt
7409inline bool algo::RnullStr1_Lt(algo::RnullStr1 lhs, algo::RnullStr1 rhs) {
7410 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
7411}
7412
7413// --- algo.RnullStr1..Cmp
7414inline i32 algo::RnullStr1_Cmp(algo::RnullStr1 lhs, algo::RnullStr1 rhs) {
7415 i32 retval = 0;
7416 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
7417 return retval;
7418}
7419
7420// --- algo.RnullStr1..Init
7421// Set all fields to initial values.
7422inline void algo::RnullStr1_Init(algo::RnullStr1& parent) {
7423 memset(parent.ch, 0, 1);
7424}
7425
7426// --- algo.RnullStr1..Eq
7427inline bool algo::RnullStr1_Eq(algo::RnullStr1 lhs, algo::RnullStr1 rhs) {
7428 bool retval = true;
7429 retval = retval
7430 &&*(u8*)(lhs.ch+0) == *(u8*)(rhs.ch+0);
7431 return retval;
7432}
7433
7434// --- algo.RnullStr1..Update
7435// Set value. Return true if new value is different from old value.
7436inline bool algo::RnullStr1_Update(algo::RnullStr1 &lhs, algo::RnullStr1 rhs) {
7437 bool ret = !RnullStr1_Eq(lhs, rhs); // compare values
7438 if (ret) {
7439 lhs = rhs; // update
7440 }
7441 return ret;
7442}
7443
7444// --- algo.RnullStr1..EqStrptr
7445inline bool algo::RnullStr1_EqStrptr(algo::RnullStr1 lhs, const algo::strptr& rhs) {
7446 return algo::strptr_Eq(ch_Getary(lhs), rhs);
7447}
7448
7449inline bool algo::RnullStr10::operator ==(const algo::RnullStr10 &rhs) const {
7450 return algo::RnullStr10_Eq(const_cast<algo::RnullStr10&>(*this),const_cast<algo::RnullStr10&>(rhs));
7451}
7452
7453inline bool algo::RnullStr10::operator !=(const algo::RnullStr10 &rhs) const {
7454 return !algo::RnullStr10_Eq(const_cast<algo::RnullStr10&>(*this),const_cast<algo::RnullStr10&>(rhs));
7455}
7456
7457inline bool algo::RnullStr10::operator ==(const algo::strptr &rhs) const {
7458 return algo::RnullStr10_EqStrptr(const_cast<algo::RnullStr10&>(*this),rhs);
7459}
7460
7461inline bool algo::RnullStr10::operator <(const algo::RnullStr10 &rhs) const {
7462 return algo::RnullStr10_Lt(const_cast<algo::RnullStr10&>(*this),const_cast<algo::RnullStr10&>(rhs));
7463}
7464
7465inline bool algo::RnullStr10::operator >(const algo::RnullStr10 &rhs) const {
7466 return rhs < *this;
7467}
7468
7469inline bool algo::RnullStr10::operator <=(const algo::RnullStr10 &rhs) const {
7470 return !(rhs < *this);
7471}
7472
7473inline bool algo::RnullStr10::operator >=(const algo::RnullStr10 &rhs) const {
7474 return !(*this < rhs);
7475}
7476inline algo::RnullStr10::RnullStr10() {
7477 algo::RnullStr10_Init(*this);
7478}
7479
7480
7481// --- algo.RnullStr10.ch.Getary
7482// Access string as array of chars
7483inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr10& parent) {
7484 int len = ch_N(parent);
7485 algo::aryptr<char> ret((char*)parent.ch, len);
7486 return ret;
7487}
7488
7489// --- algo.RnullStr10.ch.HashStrptr
7490inline u32 algo::RnullStr10_Hash(u32 prev, const algo::strptr &str) {
7491 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
7492}
7493
7494// --- algo.RnullStr10.ch.Init
7495inline void algo::ch_Init(algo::RnullStr10 &parent) {
7496 memset(parent.ch, 0, 10);
7497}
7498
7499// --- algo.RnullStr10.ch.Max
7500// always return constant 10
7501inline int algo::ch_Max(algo::RnullStr10& parent) {
7502 (void)parent;
7503 return 10;
7504}
7505
7506// --- algo.RnullStr10.ch.N
7507inline int algo::ch_N(const algo::RnullStr10& parent) {
7508 u64 ret;
7509 ret = 10;
7510 while (ret>0 && parent.ch[ret-1]==u8(0)) {
7511 ret--;
7512 }
7513 return int(ret);
7514}
7515
7516// --- algo.RnullStr10.ch.AssignStrptr
7517// Copy from strptr (operator=)
7518inline void algo::RnullStr10::operator =(const algo::strptr &str) {
7519 ch_SetStrptr(*this, str);
7520}
7521
7522// --- algo.RnullStr10.ch.Set
7523// Copy from same type
7524// Copy value from RHS.
7525inline void algo::RnullStr10::operator =(const algo::RnullStr10& parent) {
7526 memcpy(ch, parent.ch, 10);
7527}
7528
7529// --- algo.RnullStr10.ch.Ctor
7530inline algo::RnullStr10::RnullStr10(const algo::RnullStr10 &rhs) {
7531 operator =(rhs);
7532}
7533
7534// --- algo.RnullStr10.ch.CtorStrptr
7535inline algo::RnullStr10::RnullStr10(const algo::strptr &rhs) {
7536 ch_SetStrptr(*this, rhs);
7537}
7538
7539// --- algo.RnullStr10.ch.Cast
7540inline algo::RnullStr10::operator algo::strptr () const {
7541 return ch_Getary(*this);
7542}
7543
7544// --- algo.RnullStr10..Lt
7545inline bool algo::RnullStr10_Lt(algo::RnullStr10 lhs, algo::RnullStr10 rhs) {
7546 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
7547}
7548
7549// --- algo.RnullStr10..Cmp
7550inline i32 algo::RnullStr10_Cmp(algo::RnullStr10 lhs, algo::RnullStr10 rhs) {
7551 i32 retval = 0;
7552 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
7553 return retval;
7554}
7555
7556// --- algo.RnullStr10..Init
7557// Set all fields to initial values.
7558inline void algo::RnullStr10_Init(algo::RnullStr10& parent) {
7559 memset(parent.ch, 0, 10);
7560}
7561
7562// --- algo.RnullStr10..Eq
7563inline bool algo::RnullStr10_Eq(algo::RnullStr10 lhs, algo::RnullStr10 rhs) {
7564 bool retval = true;
7565 retval = retval
7566 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
7567 &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8);
7568 return retval;
7569}
7570
7571// --- algo.RnullStr10..Update
7572// Set value. Return true if new value is different from old value.
7573inline bool algo::RnullStr10_Update(algo::RnullStr10 &lhs, algo::RnullStr10 rhs) {
7574 bool ret = !RnullStr10_Eq(lhs, rhs); // compare values
7575 if (ret) {
7576 lhs = rhs; // update
7577 }
7578 return ret;
7579}
7580
7581// --- algo.RnullStr10..EqStrptr
7582inline bool algo::RnullStr10_EqStrptr(algo::RnullStr10 lhs, const algo::strptr& rhs) {
7583 return algo::strptr_Eq(ch_Getary(lhs), rhs);
7584}
7585inline algo::RnullStr100::RnullStr100() {
7586 algo::RnullStr100_Init(*this);
7587}
7588
7589
7590// --- algo.RnullStr100.ch.Getary
7591// Access string as array of chars
7592inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr100& parent) {
7593 int len = ch_N(parent);
7594 algo::aryptr<char> ret((char*)parent.ch, len);
7595 return ret;
7596}
7597
7598// --- algo.RnullStr100.ch.HashStrptr
7599inline u32 algo::RnullStr100_Hash(u32 prev, const algo::strptr &str) {
7600 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
7601}
7602
7603// --- algo.RnullStr100.ch.Init
7604inline void algo::ch_Init(algo::RnullStr100 &parent) {
7605 memset(parent.ch, 0, 100);
7606}
7607
7608// --- algo.RnullStr100.ch.Max
7609// always return constant 100
7610inline int algo::ch_Max(algo::RnullStr100& parent) {
7611 (void)parent;
7612 return 100;
7613}
7614
7615// --- algo.RnullStr100.ch.N
7616inline int algo::ch_N(const algo::RnullStr100& parent) {
7617 u64 ret;
7618 ret = 100;
7619 while (ret>0 && parent.ch[ret-1]==u8(0)) {
7620 ret--;
7621 }
7622 return int(ret);
7623}
7624
7625// --- algo.RnullStr100.ch.AssignStrptr
7626// Copy from strptr (operator=)
7627inline void algo::RnullStr100::operator =(const algo::strptr &str) {
7628 ch_SetStrptr(*this, str);
7629}
7630
7631// --- algo.RnullStr100.ch.Set
7632// Copy from same type
7633// Copy value from RHS.
7634inline void algo::RnullStr100::operator =(const algo::RnullStr100& parent) {
7635 memcpy(ch, parent.ch, 100);
7636}
7637
7638// --- algo.RnullStr100.ch.Ctor
7639inline algo::RnullStr100::RnullStr100(const algo::RnullStr100 &rhs) {
7640 operator =(rhs);
7641}
7642
7643// --- algo.RnullStr100.ch.CtorStrptr
7644inline algo::RnullStr100::RnullStr100(const algo::strptr &rhs) {
7645 ch_SetStrptr(*this, rhs);
7646}
7647
7648// --- algo.RnullStr100.ch.Cast
7649inline algo::RnullStr100::operator algo::strptr () const {
7650 return ch_Getary(*this);
7651}
7652
7653// --- algo.RnullStr100..Lt
7654inline bool algo::RnullStr100_Lt(algo::RnullStr100& lhs, algo::RnullStr100& rhs) {
7655 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
7656}
7657
7658// --- algo.RnullStr100..Cmp
7659inline i32 algo::RnullStr100_Cmp(algo::RnullStr100& lhs, algo::RnullStr100& rhs) {
7660 i32 retval = 0;
7661 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
7662 return retval;
7663}
7664
7665// --- algo.RnullStr100..Init
7666// Set all fields to initial values.
7667inline void algo::RnullStr100_Init(algo::RnullStr100& parent) {
7668 memset(parent.ch, 0, 100);
7669}
7670
7671// --- algo.RnullStr100..Eq
7672inline bool algo::RnullStr100_Eq(algo::RnullStr100& lhs, algo::RnullStr100& rhs) {
7673 bool retval = true;
7674 retval = retval
7675 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
7676 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
7677 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
7678 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
7679 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
7680 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
7681 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
7682 &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
7683 &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
7684 &&*(u64*)(lhs.ch+72) == *(u64*)(rhs.ch+72)
7685 &&*(u64*)(lhs.ch+80) == *(u64*)(rhs.ch+80)
7686 &&*(u64*)(lhs.ch+88) == *(u64*)(rhs.ch+88)
7687 &&*(u32*)(lhs.ch+96) == *(u32*)(rhs.ch+96);
7688 return retval;
7689}
7690
7691// --- algo.RnullStr100..Update
7692// Set value. Return true if new value is different from old value.
7693inline bool algo::RnullStr100_Update(algo::RnullStr100 &lhs, algo::RnullStr100& rhs) {
7694 bool ret = !RnullStr100_Eq(lhs, rhs); // compare values
7695 if (ret) {
7696 lhs = rhs; // update
7697 }
7698 return ret;
7699}
7700
7701// --- algo.RnullStr100..EqStrptr
7702inline bool algo::RnullStr100_EqStrptr(const algo::RnullStr100& lhs, const algo::strptr& rhs) {
7703 return algo::strptr_Eq(ch_Getary(lhs), rhs);
7704}
7705
7706inline bool algo::RnullStr1000::operator ==(const algo::RnullStr1000 &rhs) const {
7707 return algo::RnullStr1000_Eq(const_cast<algo::RnullStr1000&>(*this),const_cast<algo::RnullStr1000&>(rhs));
7708}
7709
7710inline bool algo::RnullStr1000::operator !=(const algo::RnullStr1000 &rhs) const {
7711 return !algo::RnullStr1000_Eq(const_cast<algo::RnullStr1000&>(*this),const_cast<algo::RnullStr1000&>(rhs));
7712}
7713
7714inline bool algo::RnullStr1000::operator ==(const algo::strptr &rhs) const {
7715 return algo::RnullStr1000_EqStrptr(const_cast<algo::RnullStr1000&>(*this),rhs);
7716}
7717
7718inline bool algo::RnullStr1000::operator <(const algo::RnullStr1000 &rhs) const {
7719 return algo::RnullStr1000_Lt(const_cast<algo::RnullStr1000&>(*this),const_cast<algo::RnullStr1000&>(rhs));
7720}
7721
7722inline bool algo::RnullStr1000::operator >(const algo::RnullStr1000 &rhs) const {
7723 return rhs < *this;
7724}
7725
7726inline bool algo::RnullStr1000::operator <=(const algo::RnullStr1000 &rhs) const {
7727 return !(rhs < *this);
7728}
7729
7730inline bool algo::RnullStr1000::operator >=(const algo::RnullStr1000 &rhs) const {
7731 return !(*this < rhs);
7732}
7733inline algo::RnullStr1000::RnullStr1000() {
7734 algo::RnullStr1000_Init(*this);
7735}
7736
7737
7738// --- algo.RnullStr1000.ch.Getary
7739// Access string as array of chars
7740inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr1000& parent) {
7741 int len = ch_N(parent);
7742 algo::aryptr<char> ret((char*)parent.ch, len);
7743 return ret;
7744}
7745
7746// --- algo.RnullStr1000.ch.HashStrptr
7747inline u32 algo::RnullStr1000_Hash(u32 prev, const algo::strptr &str) {
7748 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
7749}
7750
7751// --- algo.RnullStr1000.ch.Init
7752inline void algo::ch_Init(algo::RnullStr1000 &parent) {
7753 memset(parent.ch, 0, 1000);
7754}
7755
7756// --- algo.RnullStr1000.ch.Max
7757// always return constant 1000
7758inline int algo::ch_Max(algo::RnullStr1000& parent) {
7759 (void)parent;
7760 return 1000;
7761}
7762
7763// --- algo.RnullStr1000.ch.N
7764inline int algo::ch_N(const algo::RnullStr1000& parent) {
7765 u64 ret;
7766 ret = 1000;
7767 while (ret>0 && parent.ch[ret-1]==u8(0)) {
7768 ret--;
7769 }
7770 return int(ret);
7771}
7772
7773// --- algo.RnullStr1000.ch.AssignStrptr
7774// Copy from strptr (operator=)
7775inline void algo::RnullStr1000::operator =(const algo::strptr &str) {
7776 ch_SetStrptr(*this, str);
7777}
7778
7779// --- algo.RnullStr1000.ch.Set
7780// Copy from same type
7781// Copy value from RHS.
7782inline void algo::RnullStr1000::operator =(const algo::RnullStr1000& parent) {
7783 memcpy(ch, parent.ch, 1000);
7784}
7785
7786// --- algo.RnullStr1000.ch.Ctor
7787inline algo::RnullStr1000::RnullStr1000(const algo::RnullStr1000 &rhs) {
7788 operator =(rhs);
7789}
7790
7791// --- algo.RnullStr1000.ch.CtorStrptr
7792inline algo::RnullStr1000::RnullStr1000(const algo::strptr &rhs) {
7793 ch_SetStrptr(*this, rhs);
7794}
7795
7796// --- algo.RnullStr1000.ch.Cast
7797inline algo::RnullStr1000::operator algo::strptr () const {
7798 return ch_Getary(*this);
7799}
7800
7801// --- algo.RnullStr1000..Lt
7802inline bool algo::RnullStr1000_Lt(algo::RnullStr1000& lhs, algo::RnullStr1000& rhs) {
7803 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
7804}
7805
7806// --- algo.RnullStr1000..Cmp
7807inline i32 algo::RnullStr1000_Cmp(algo::RnullStr1000& lhs, algo::RnullStr1000& rhs) {
7808 i32 retval = 0;
7809 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
7810 return retval;
7811}
7812
7813// --- algo.RnullStr1000..Init
7814// Set all fields to initial values.
7815inline void algo::RnullStr1000_Init(algo::RnullStr1000& parent) {
7816 memset(parent.ch, 0, 1000);
7817}
7818
7819// --- algo.RnullStr1000..Eq
7820inline bool algo::RnullStr1000_Eq(algo::RnullStr1000& lhs, algo::RnullStr1000& rhs) {
7821 bool retval = true;
7822 for (int i=0; i<125 && retval; i++) {
7823 retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
7824 }
7825 return retval;
7826}
7827
7828// --- algo.RnullStr1000..Update
7829// Set value. Return true if new value is different from old value.
7830inline bool algo::RnullStr1000_Update(algo::RnullStr1000 &lhs, algo::RnullStr1000& rhs) {
7831 bool ret = !RnullStr1000_Eq(lhs, rhs); // compare values
7832 if (ret) {
7833 lhs = rhs; // update
7834 }
7835 return ret;
7836}
7837
7838// --- algo.RnullStr1000..EqStrptr
7839inline bool algo::RnullStr1000_EqStrptr(const algo::RnullStr1000& lhs, const algo::strptr& rhs) {
7840 return algo::strptr_Eq(ch_Getary(lhs), rhs);
7841}
7842
7843inline bool algo::RnullStr11::operator ==(const algo::RnullStr11 &rhs) const {
7844 return algo::RnullStr11_Eq(const_cast<algo::RnullStr11&>(*this),const_cast<algo::RnullStr11&>(rhs));
7845}
7846
7847inline bool algo::RnullStr11::operator !=(const algo::RnullStr11 &rhs) const {
7848 return !algo::RnullStr11_Eq(const_cast<algo::RnullStr11&>(*this),const_cast<algo::RnullStr11&>(rhs));
7849}
7850
7851inline bool algo::RnullStr11::operator ==(const algo::strptr &rhs) const {
7852 return algo::RnullStr11_EqStrptr(const_cast<algo::RnullStr11&>(*this),rhs);
7853}
7854
7855inline bool algo::RnullStr11::operator <(const algo::RnullStr11 &rhs) const {
7856 return algo::RnullStr11_Lt(const_cast<algo::RnullStr11&>(*this),const_cast<algo::RnullStr11&>(rhs));
7857}
7858
7859inline bool algo::RnullStr11::operator >(const algo::RnullStr11 &rhs) const {
7860 return rhs < *this;
7861}
7862
7863inline bool algo::RnullStr11::operator <=(const algo::RnullStr11 &rhs) const {
7864 return !(rhs < *this);
7865}
7866
7867inline bool algo::RnullStr11::operator >=(const algo::RnullStr11 &rhs) const {
7868 return !(*this < rhs);
7869}
7870inline algo::RnullStr11::RnullStr11() {
7871 algo::RnullStr11_Init(*this);
7872}
7873
7874
7875// --- algo.RnullStr11.ch.Getary
7876// Access string as array of chars
7877inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr11& parent) {
7878 int len = ch_N(parent);
7879 algo::aryptr<char> ret((char*)parent.ch, len);
7880 return ret;
7881}
7882
7883// --- algo.RnullStr11.ch.HashStrptr
7884inline u32 algo::RnullStr11_Hash(u32 prev, const algo::strptr &str) {
7885 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
7886}
7887
7888// --- algo.RnullStr11.ch.Init
7889inline void algo::ch_Init(algo::RnullStr11 &parent) {
7890 memset(parent.ch, 0, 11);
7891}
7892
7893// --- algo.RnullStr11.ch.Max
7894// always return constant 11
7895inline int algo::ch_Max(algo::RnullStr11& parent) {
7896 (void)parent;
7897 return 11;
7898}
7899
7900// --- algo.RnullStr11.ch.N
7901inline int algo::ch_N(const algo::RnullStr11& parent) {
7902 u64 ret;
7903 ret = 11;
7904 while (ret>0 && parent.ch[ret-1]==u8(0)) {
7905 ret--;
7906 }
7907 return int(ret);
7908}
7909
7910// --- algo.RnullStr11.ch.AssignStrptr
7911// Copy from strptr (operator=)
7912inline void algo::RnullStr11::operator =(const algo::strptr &str) {
7913 ch_SetStrptr(*this, str);
7914}
7915
7916// --- algo.RnullStr11.ch.Set
7917// Copy from same type
7918// Copy value from RHS.
7919inline void algo::RnullStr11::operator =(const algo::RnullStr11& parent) {
7920 memcpy(ch, parent.ch, 11);
7921}
7922
7923// --- algo.RnullStr11.ch.Ctor
7924inline algo::RnullStr11::RnullStr11(const algo::RnullStr11 &rhs) {
7925 operator =(rhs);
7926}
7927
7928// --- algo.RnullStr11.ch.CtorStrptr
7929inline algo::RnullStr11::RnullStr11(const algo::strptr &rhs) {
7930 ch_SetStrptr(*this, rhs);
7931}
7932
7933// --- algo.RnullStr11.ch.Cast
7934inline algo::RnullStr11::operator algo::strptr () const {
7935 return ch_Getary(*this);
7936}
7937
7938// --- algo.RnullStr11..Lt
7939inline bool algo::RnullStr11_Lt(algo::RnullStr11& lhs, algo::RnullStr11& rhs) {
7940 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
7941}
7942
7943// --- algo.RnullStr11..Cmp
7944inline i32 algo::RnullStr11_Cmp(algo::RnullStr11& lhs, algo::RnullStr11& rhs) {
7945 i32 retval = 0;
7946 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
7947 return retval;
7948}
7949
7950// --- algo.RnullStr11..Init
7951// Set all fields to initial values.
7952inline void algo::RnullStr11_Init(algo::RnullStr11& parent) {
7953 memset(parent.ch, 0, 11);
7954}
7955
7956// --- algo.RnullStr11..Eq
7957inline bool algo::RnullStr11_Eq(algo::RnullStr11& lhs, algo::RnullStr11& rhs) {
7958 bool retval = true;
7959 retval = retval
7960 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
7961 &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8)
7962 &&*(u8*)(lhs.ch+10) == *(u8*)(rhs.ch+10);
7963 return retval;
7964}
7965
7966// --- algo.RnullStr11..Update
7967// Set value. Return true if new value is different from old value.
7968inline bool algo::RnullStr11_Update(algo::RnullStr11 &lhs, algo::RnullStr11& rhs) {
7969 bool ret = !RnullStr11_Eq(lhs, rhs); // compare values
7970 if (ret) {
7971 lhs = rhs; // update
7972 }
7973 return ret;
7974}
7975
7976// --- algo.RnullStr11..EqStrptr
7977inline bool algo::RnullStr11_EqStrptr(const algo::RnullStr11& lhs, const algo::strptr& rhs) {
7978 return algo::strptr_Eq(ch_Getary(lhs), rhs);
7979}
7980
7981inline bool algo::RnullStr12::operator ==(const algo::RnullStr12 &rhs) const {
7982 return algo::RnullStr12_Eq(const_cast<algo::RnullStr12&>(*this),const_cast<algo::RnullStr12&>(rhs));
7983}
7984
7985inline bool algo::RnullStr12::operator !=(const algo::RnullStr12 &rhs) const {
7986 return !algo::RnullStr12_Eq(const_cast<algo::RnullStr12&>(*this),const_cast<algo::RnullStr12&>(rhs));
7987}
7988
7989inline bool algo::RnullStr12::operator ==(const algo::strptr &rhs) const {
7990 return algo::RnullStr12_EqStrptr(const_cast<algo::RnullStr12&>(*this),rhs);
7991}
7992
7993inline bool algo::RnullStr12::operator <(const algo::RnullStr12 &rhs) const {
7994 return algo::RnullStr12_Lt(const_cast<algo::RnullStr12&>(*this),const_cast<algo::RnullStr12&>(rhs));
7995}
7996
7997inline bool algo::RnullStr12::operator >(const algo::RnullStr12 &rhs) const {
7998 return rhs < *this;
7999}
8000
8001inline bool algo::RnullStr12::operator <=(const algo::RnullStr12 &rhs) const {
8002 return !(rhs < *this);
8003}
8004
8005inline bool algo::RnullStr12::operator >=(const algo::RnullStr12 &rhs) const {
8006 return !(*this < rhs);
8007}
8008inline algo::RnullStr12::RnullStr12() {
8009 algo::RnullStr12_Init(*this);
8010}
8011
8012
8013// --- algo.RnullStr12.ch.Getary
8014// Access string as array of chars
8015inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr12& parent) {
8016 int len = ch_N(parent);
8017 algo::aryptr<char> ret((char*)parent.ch, len);
8018 return ret;
8019}
8020
8021// --- algo.RnullStr12.ch.HashStrptr
8022inline u32 algo::RnullStr12_Hash(u32 prev, const algo::strptr &str) {
8023 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
8024}
8025
8026// --- algo.RnullStr12.ch.Init
8027inline void algo::ch_Init(algo::RnullStr12 &parent) {
8028 memset(parent.ch, 0, 12);
8029}
8030
8031// --- algo.RnullStr12.ch.Max
8032// always return constant 12
8033inline int algo::ch_Max(algo::RnullStr12& parent) {
8034 (void)parent;
8035 return 12;
8036}
8037
8038// --- algo.RnullStr12.ch.N
8039inline int algo::ch_N(const algo::RnullStr12& parent) {
8040 u64 ret;
8041 ret = 12;
8042 while (ret>0 && parent.ch[ret-1]==u8(0)) {
8043 ret--;
8044 }
8045 return int(ret);
8046}
8047
8048// --- algo.RnullStr12.ch.AssignStrptr
8049// Copy from strptr (operator=)
8050inline void algo::RnullStr12::operator =(const algo::strptr &str) {
8051 ch_SetStrptr(*this, str);
8052}
8053
8054// --- algo.RnullStr12.ch.Set
8055// Copy from same type
8056// Copy value from RHS.
8057inline void algo::RnullStr12::operator =(const algo::RnullStr12& parent) {
8058 memcpy(ch, parent.ch, 12);
8059}
8060
8061// --- algo.RnullStr12.ch.Ctor
8062inline algo::RnullStr12::RnullStr12(const algo::RnullStr12 &rhs) {
8063 operator =(rhs);
8064}
8065
8066// --- algo.RnullStr12.ch.CtorStrptr
8067inline algo::RnullStr12::RnullStr12(const algo::strptr &rhs) {
8068 ch_SetStrptr(*this, rhs);
8069}
8070
8071// --- algo.RnullStr12.ch.Cast
8072inline algo::RnullStr12::operator algo::strptr () const {
8073 return ch_Getary(*this);
8074}
8075
8076// --- algo.RnullStr12..Lt
8077inline bool algo::RnullStr12_Lt(algo::RnullStr12& lhs, algo::RnullStr12& rhs) {
8078 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
8079}
8080
8081// --- algo.RnullStr12..Cmp
8082inline i32 algo::RnullStr12_Cmp(algo::RnullStr12& lhs, algo::RnullStr12& rhs) {
8083 i32 retval = 0;
8084 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
8085 return retval;
8086}
8087
8088// --- algo.RnullStr12..Init
8089// Set all fields to initial values.
8090inline void algo::RnullStr12_Init(algo::RnullStr12& parent) {
8091 memset(parent.ch, 0, 12);
8092}
8093
8094// --- algo.RnullStr12..Eq
8095inline bool algo::RnullStr12_Eq(algo::RnullStr12& lhs, algo::RnullStr12& rhs) {
8096 bool retval = true;
8097 retval = retval
8098 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
8099 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8);
8100 return retval;
8101}
8102
8103// --- algo.RnullStr12..Update
8104// Set value. Return true if new value is different from old value.
8105inline bool algo::RnullStr12_Update(algo::RnullStr12 &lhs, algo::RnullStr12& rhs) {
8106 bool ret = !RnullStr12_Eq(lhs, rhs); // compare values
8107 if (ret) {
8108 lhs = rhs; // update
8109 }
8110 return ret;
8111}
8112
8113// --- algo.RnullStr12..EqStrptr
8114inline bool algo::RnullStr12_EqStrptr(const algo::RnullStr12& lhs, const algo::strptr& rhs) {
8115 return algo::strptr_Eq(ch_Getary(lhs), rhs);
8116}
8117
8118inline bool algo::RnullStr129::operator ==(const algo::RnullStr129 &rhs) const {
8119 return algo::RnullStr129_Eq(const_cast<algo::RnullStr129&>(*this),const_cast<algo::RnullStr129&>(rhs));
8120}
8121
8122inline bool algo::RnullStr129::operator !=(const algo::RnullStr129 &rhs) const {
8123 return !algo::RnullStr129_Eq(const_cast<algo::RnullStr129&>(*this),const_cast<algo::RnullStr129&>(rhs));
8124}
8125
8126inline bool algo::RnullStr129::operator ==(const algo::strptr &rhs) const {
8127 return algo::RnullStr129_EqStrptr(const_cast<algo::RnullStr129&>(*this),rhs);
8128}
8129
8130inline bool algo::RnullStr129::operator <(const algo::RnullStr129 &rhs) const {
8131 return algo::RnullStr129_Lt(const_cast<algo::RnullStr129&>(*this),const_cast<algo::RnullStr129&>(rhs));
8132}
8133
8134inline bool algo::RnullStr129::operator >(const algo::RnullStr129 &rhs) const {
8135 return rhs < *this;
8136}
8137
8138inline bool algo::RnullStr129::operator <=(const algo::RnullStr129 &rhs) const {
8139 return !(rhs < *this);
8140}
8141
8142inline bool algo::RnullStr129::operator >=(const algo::RnullStr129 &rhs) const {
8143 return !(*this < rhs);
8144}
8145inline algo::RnullStr129::RnullStr129() {
8146 algo::RnullStr129_Init(*this);
8147}
8148
8149
8150// --- algo.RnullStr129.ch.Getary
8151// Access string as array of chars
8152inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr129& parent) {
8153 int len = ch_N(parent);
8154 algo::aryptr<char> ret((char*)parent.ch, len);
8155 return ret;
8156}
8157
8158// --- algo.RnullStr129.ch.HashStrptr
8159inline u32 algo::RnullStr129_Hash(u32 prev, const algo::strptr &str) {
8160 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
8161}
8162
8163// --- algo.RnullStr129.ch.Init
8164inline void algo::ch_Init(algo::RnullStr129 &parent) {
8165 memset(parent.ch, 0, 129);
8166}
8167
8168// --- algo.RnullStr129.ch.Max
8169// always return constant 129
8170inline int algo::ch_Max(algo::RnullStr129& parent) {
8171 (void)parent;
8172 return 129;
8173}
8174
8175// --- algo.RnullStr129.ch.N
8176inline int algo::ch_N(const algo::RnullStr129& parent) {
8177 u64 ret;
8178 ret = 129;
8179 while (ret>0 && parent.ch[ret-1]==u8(0)) {
8180 ret--;
8181 }
8182 return int(ret);
8183}
8184
8185// --- algo.RnullStr129.ch.AssignStrptr
8186// Copy from strptr (operator=)
8187inline void algo::RnullStr129::operator =(const algo::strptr &str) {
8188 ch_SetStrptr(*this, str);
8189}
8190
8191// --- algo.RnullStr129.ch.Set
8192// Copy from same type
8193// Copy value from RHS.
8194inline void algo::RnullStr129::operator =(const algo::RnullStr129& parent) {
8195 memcpy(ch, parent.ch, 129);
8196}
8197
8198// --- algo.RnullStr129.ch.Ctor
8199inline algo::RnullStr129::RnullStr129(const algo::RnullStr129 &rhs) {
8200 operator =(rhs);
8201}
8202
8203// --- algo.RnullStr129.ch.CtorStrptr
8204inline algo::RnullStr129::RnullStr129(const algo::strptr &rhs) {
8205 ch_SetStrptr(*this, rhs);
8206}
8207
8208// --- algo.RnullStr129.ch.Cast
8209inline algo::RnullStr129::operator algo::strptr () const {
8210 return ch_Getary(*this);
8211}
8212
8213// --- algo.RnullStr129..Lt
8214inline bool algo::RnullStr129_Lt(algo::RnullStr129& lhs, algo::RnullStr129& rhs) {
8215 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
8216}
8217
8218// --- algo.RnullStr129..Cmp
8219inline i32 algo::RnullStr129_Cmp(algo::RnullStr129& lhs, algo::RnullStr129& rhs) {
8220 i32 retval = 0;
8221 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
8222 return retval;
8223}
8224
8225// --- algo.RnullStr129..Init
8226// Set all fields to initial values.
8227inline void algo::RnullStr129_Init(algo::RnullStr129& parent) {
8228 memset(parent.ch, 0, 129);
8229}
8230
8231// --- algo.RnullStr129..Eq
8232inline bool algo::RnullStr129_Eq(algo::RnullStr129& lhs, algo::RnullStr129& rhs) {
8233 bool retval = true;
8234 for (int i=0; i<16 && retval; i++) {
8235 retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
8236 }
8237 retval = retval
8238 &&*(u8*)(lhs.ch+128) == *(u8*)(rhs.ch+128);
8239 return retval;
8240}
8241
8242// --- algo.RnullStr129..Update
8243// Set value. Return true if new value is different from old value.
8244inline bool algo::RnullStr129_Update(algo::RnullStr129 &lhs, algo::RnullStr129& rhs) {
8245 bool ret = !RnullStr129_Eq(lhs, rhs); // compare values
8246 if (ret) {
8247 lhs = rhs; // update
8248 }
8249 return ret;
8250}
8251
8252// --- algo.RnullStr129..EqStrptr
8253inline bool algo::RnullStr129_EqStrptr(const algo::RnullStr129& lhs, const algo::strptr& rhs) {
8254 return algo::strptr_Eq(ch_Getary(lhs), rhs);
8255}
8256
8257inline bool algo::RnullStr13::operator ==(const algo::RnullStr13 &rhs) const {
8258 return algo::RnullStr13_Eq(const_cast<algo::RnullStr13&>(*this),const_cast<algo::RnullStr13&>(rhs));
8259}
8260
8261inline bool algo::RnullStr13::operator !=(const algo::RnullStr13 &rhs) const {
8262 return !algo::RnullStr13_Eq(const_cast<algo::RnullStr13&>(*this),const_cast<algo::RnullStr13&>(rhs));
8263}
8264
8265inline bool algo::RnullStr13::operator ==(const algo::strptr &rhs) const {
8266 return algo::RnullStr13_EqStrptr(const_cast<algo::RnullStr13&>(*this),rhs);
8267}
8268
8269inline bool algo::RnullStr13::operator <(const algo::RnullStr13 &rhs) const {
8270 return algo::RnullStr13_Lt(const_cast<algo::RnullStr13&>(*this),const_cast<algo::RnullStr13&>(rhs));
8271}
8272
8273inline bool algo::RnullStr13::operator >(const algo::RnullStr13 &rhs) const {
8274 return rhs < *this;
8275}
8276
8277inline bool algo::RnullStr13::operator <=(const algo::RnullStr13 &rhs) const {
8278 return !(rhs < *this);
8279}
8280
8281inline bool algo::RnullStr13::operator >=(const algo::RnullStr13 &rhs) const {
8282 return !(*this < rhs);
8283}
8284inline algo::RnullStr13::RnullStr13() {
8285 algo::RnullStr13_Init(*this);
8286}
8287
8288
8289// --- algo.RnullStr13.ch.Getary
8290// Access string as array of chars
8291inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr13& parent) {
8292 int len = ch_N(parent);
8293 algo::aryptr<char> ret((char*)parent.ch, len);
8294 return ret;
8295}
8296
8297// --- algo.RnullStr13.ch.HashStrptr
8298inline u32 algo::RnullStr13_Hash(u32 prev, const algo::strptr &str) {
8299 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
8300}
8301
8302// --- algo.RnullStr13.ch.Init
8303inline void algo::ch_Init(algo::RnullStr13 &parent) {
8304 memset(parent.ch, 0, 13);
8305}
8306
8307// --- algo.RnullStr13.ch.Max
8308// always return constant 13
8309inline int algo::ch_Max(algo::RnullStr13& parent) {
8310 (void)parent;
8311 return 13;
8312}
8313
8314// --- algo.RnullStr13.ch.N
8315inline int algo::ch_N(const algo::RnullStr13& parent) {
8316 u64 ret;
8317 ret = 13;
8318 while (ret>0 && parent.ch[ret-1]==u8(0)) {
8319 ret--;
8320 }
8321 return int(ret);
8322}
8323
8324// --- algo.RnullStr13.ch.AssignStrptr
8325// Copy from strptr (operator=)
8326inline void algo::RnullStr13::operator =(const algo::strptr &str) {
8327 ch_SetStrptr(*this, str);
8328}
8329
8330// --- algo.RnullStr13.ch.Set
8331// Copy from same type
8332// Copy value from RHS.
8333inline void algo::RnullStr13::operator =(const algo::RnullStr13& parent) {
8334 memcpy(ch, parent.ch, 13);
8335}
8336
8337// --- algo.RnullStr13.ch.Ctor
8338inline algo::RnullStr13::RnullStr13(const algo::RnullStr13 &rhs) {
8339 operator =(rhs);
8340}
8341
8342// --- algo.RnullStr13.ch.CtorStrptr
8343inline algo::RnullStr13::RnullStr13(const algo::strptr &rhs) {
8344 ch_SetStrptr(*this, rhs);
8345}
8346
8347// --- algo.RnullStr13.ch.Cast
8348inline algo::RnullStr13::operator algo::strptr () const {
8349 return ch_Getary(*this);
8350}
8351
8352// --- algo.RnullStr13..Lt
8353inline bool algo::RnullStr13_Lt(algo::RnullStr13& lhs, algo::RnullStr13& rhs) {
8354 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
8355}
8356
8357// --- algo.RnullStr13..Cmp
8358inline i32 algo::RnullStr13_Cmp(algo::RnullStr13& lhs, algo::RnullStr13& rhs) {
8359 i32 retval = 0;
8360 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
8361 return retval;
8362}
8363
8364// --- algo.RnullStr13..Init
8365// Set all fields to initial values.
8366inline void algo::RnullStr13_Init(algo::RnullStr13& parent) {
8367 memset(parent.ch, 0, 13);
8368}
8369
8370// --- algo.RnullStr13..Eq
8371inline bool algo::RnullStr13_Eq(algo::RnullStr13& lhs, algo::RnullStr13& rhs) {
8372 bool retval = true;
8373 retval = retval
8374 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
8375 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
8376 &&*(u8*)(lhs.ch+12) == *(u8*)(rhs.ch+12);
8377 return retval;
8378}
8379
8380// --- algo.RnullStr13..Update
8381// Set value. Return true if new value is different from old value.
8382inline bool algo::RnullStr13_Update(algo::RnullStr13 &lhs, algo::RnullStr13& rhs) {
8383 bool ret = !RnullStr13_Eq(lhs, rhs); // compare values
8384 if (ret) {
8385 lhs = rhs; // update
8386 }
8387 return ret;
8388}
8389
8390// --- algo.RnullStr13..EqStrptr
8391inline bool algo::RnullStr13_EqStrptr(const algo::RnullStr13& lhs, const algo::strptr& rhs) {
8392 return algo::strptr_Eq(ch_Getary(lhs), rhs);
8393}
8394
8395inline bool algo::RnullStr14::operator ==(const algo::RnullStr14 &rhs) const {
8396 return algo::RnullStr14_Eq(const_cast<algo::RnullStr14&>(*this),const_cast<algo::RnullStr14&>(rhs));
8397}
8398
8399inline bool algo::RnullStr14::operator !=(const algo::RnullStr14 &rhs) const {
8400 return !algo::RnullStr14_Eq(const_cast<algo::RnullStr14&>(*this),const_cast<algo::RnullStr14&>(rhs));
8401}
8402
8403inline bool algo::RnullStr14::operator ==(const algo::strptr &rhs) const {
8404 return algo::RnullStr14_EqStrptr(const_cast<algo::RnullStr14&>(*this),rhs);
8405}
8406
8407inline bool algo::RnullStr14::operator <(const algo::RnullStr14 &rhs) const {
8408 return algo::RnullStr14_Lt(const_cast<algo::RnullStr14&>(*this),const_cast<algo::RnullStr14&>(rhs));
8409}
8410
8411inline bool algo::RnullStr14::operator >(const algo::RnullStr14 &rhs) const {
8412 return rhs < *this;
8413}
8414
8415inline bool algo::RnullStr14::operator <=(const algo::RnullStr14 &rhs) const {
8416 return !(rhs < *this);
8417}
8418
8419inline bool algo::RnullStr14::operator >=(const algo::RnullStr14 &rhs) const {
8420 return !(*this < rhs);
8421}
8422inline algo::RnullStr14::RnullStr14() {
8423 algo::RnullStr14_Init(*this);
8424}
8425
8426
8427// --- algo.RnullStr14.ch.Getary
8428// Access string as array of chars
8429inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr14& parent) {
8430 int len = ch_N(parent);
8431 algo::aryptr<char> ret((char*)parent.ch, len);
8432 return ret;
8433}
8434
8435// --- algo.RnullStr14.ch.HashStrptr
8436inline u32 algo::RnullStr14_Hash(u32 prev, const algo::strptr &str) {
8437 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
8438}
8439
8440// --- algo.RnullStr14.ch.Init
8441inline void algo::ch_Init(algo::RnullStr14 &parent) {
8442 memset(parent.ch, 0, 14);
8443}
8444
8445// --- algo.RnullStr14.ch.Max
8446// always return constant 14
8447inline int algo::ch_Max(algo::RnullStr14& parent) {
8448 (void)parent;
8449 return 14;
8450}
8451
8452// --- algo.RnullStr14.ch.N
8453inline int algo::ch_N(const algo::RnullStr14& parent) {
8454 u64 ret;
8455 ret = 14;
8456 while (ret>0 && parent.ch[ret-1]==u8(0)) {
8457 ret--;
8458 }
8459 return int(ret);
8460}
8461
8462// --- algo.RnullStr14.ch.AssignStrptr
8463// Copy from strptr (operator=)
8464inline void algo::RnullStr14::operator =(const algo::strptr &str) {
8465 ch_SetStrptr(*this, str);
8466}
8467
8468// --- algo.RnullStr14.ch.Set
8469// Copy from same type
8470// Copy value from RHS.
8471inline void algo::RnullStr14::operator =(const algo::RnullStr14& parent) {
8472 memcpy(ch, parent.ch, 14);
8473}
8474
8475// --- algo.RnullStr14.ch.Ctor
8476inline algo::RnullStr14::RnullStr14(const algo::RnullStr14 &rhs) {
8477 operator =(rhs);
8478}
8479
8480// --- algo.RnullStr14.ch.CtorStrptr
8481inline algo::RnullStr14::RnullStr14(const algo::strptr &rhs) {
8482 ch_SetStrptr(*this, rhs);
8483}
8484
8485// --- algo.RnullStr14.ch.Cast
8486inline algo::RnullStr14::operator algo::strptr () const {
8487 return ch_Getary(*this);
8488}
8489
8490// --- algo.RnullStr14..Lt
8491inline bool algo::RnullStr14_Lt(algo::RnullStr14& lhs, algo::RnullStr14& rhs) {
8492 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
8493}
8494
8495// --- algo.RnullStr14..Cmp
8496inline i32 algo::RnullStr14_Cmp(algo::RnullStr14& lhs, algo::RnullStr14& rhs) {
8497 i32 retval = 0;
8498 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
8499 return retval;
8500}
8501
8502// --- algo.RnullStr14..Init
8503// Set all fields to initial values.
8504inline void algo::RnullStr14_Init(algo::RnullStr14& parent) {
8505 memset(parent.ch, 0, 14);
8506}
8507
8508// --- algo.RnullStr14..Eq
8509inline bool algo::RnullStr14_Eq(algo::RnullStr14& lhs, algo::RnullStr14& rhs) {
8510 bool retval = true;
8511 retval = retval
8512 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
8513 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
8514 &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12);
8515 return retval;
8516}
8517
8518// --- algo.RnullStr14..Update
8519// Set value. Return true if new value is different from old value.
8520inline bool algo::RnullStr14_Update(algo::RnullStr14 &lhs, algo::RnullStr14& rhs) {
8521 bool ret = !RnullStr14_Eq(lhs, rhs); // compare values
8522 if (ret) {
8523 lhs = rhs; // update
8524 }
8525 return ret;
8526}
8527
8528// --- algo.RnullStr14..EqStrptr
8529inline bool algo::RnullStr14_EqStrptr(const algo::RnullStr14& lhs, const algo::strptr& rhs) {
8530 return algo::strptr_Eq(ch_Getary(lhs), rhs);
8531}
8532
8533inline bool algo::RnullStr15::operator ==(const algo::RnullStr15 &rhs) const {
8534 return algo::RnullStr15_Eq(const_cast<algo::RnullStr15&>(*this),const_cast<algo::RnullStr15&>(rhs));
8535}
8536
8537inline bool algo::RnullStr15::operator !=(const algo::RnullStr15 &rhs) const {
8538 return !algo::RnullStr15_Eq(const_cast<algo::RnullStr15&>(*this),const_cast<algo::RnullStr15&>(rhs));
8539}
8540
8541inline bool algo::RnullStr15::operator ==(const algo::strptr &rhs) const {
8542 return algo::RnullStr15_EqStrptr(const_cast<algo::RnullStr15&>(*this),rhs);
8543}
8544
8545inline bool algo::RnullStr15::operator <(const algo::RnullStr15 &rhs) const {
8546 return algo::RnullStr15_Lt(const_cast<algo::RnullStr15&>(*this),const_cast<algo::RnullStr15&>(rhs));
8547}
8548
8549inline bool algo::RnullStr15::operator >(const algo::RnullStr15 &rhs) const {
8550 return rhs < *this;
8551}
8552
8553inline bool algo::RnullStr15::operator <=(const algo::RnullStr15 &rhs) const {
8554 return !(rhs < *this);
8555}
8556
8557inline bool algo::RnullStr15::operator >=(const algo::RnullStr15 &rhs) const {
8558 return !(*this < rhs);
8559}
8560inline algo::RnullStr15::RnullStr15() {
8561 algo::RnullStr15_Init(*this);
8562}
8563
8564
8565// --- algo.RnullStr15.ch.Getary
8566// Access string as array of chars
8567inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr15& parent) {
8568 int len = ch_N(parent);
8569 algo::aryptr<char> ret((char*)parent.ch, len);
8570 return ret;
8571}
8572
8573// --- algo.RnullStr15.ch.HashStrptr
8574inline u32 algo::RnullStr15_Hash(u32 prev, const algo::strptr &str) {
8575 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
8576}
8577
8578// --- algo.RnullStr15.ch.Init
8579inline void algo::ch_Init(algo::RnullStr15 &parent) {
8580 memset(parent.ch, 0, 15);
8581}
8582
8583// --- algo.RnullStr15.ch.Max
8584// always return constant 15
8585inline int algo::ch_Max(algo::RnullStr15& parent) {
8586 (void)parent;
8587 return 15;
8588}
8589
8590// --- algo.RnullStr15.ch.N
8591inline int algo::ch_N(const algo::RnullStr15& parent) {
8592 u64 ret;
8593 ret = 15;
8594 while (ret>0 && parent.ch[ret-1]==u8(0)) {
8595 ret--;
8596 }
8597 return int(ret);
8598}
8599
8600// --- algo.RnullStr15.ch.AssignStrptr
8601// Copy from strptr (operator=)
8602inline void algo::RnullStr15::operator =(const algo::strptr &str) {
8603 ch_SetStrptr(*this, str);
8604}
8605
8606// --- algo.RnullStr15.ch.Set
8607// Copy from same type
8608// Copy value from RHS.
8609inline void algo::RnullStr15::operator =(const algo::RnullStr15& parent) {
8610 memcpy(ch, parent.ch, 15);
8611}
8612
8613// --- algo.RnullStr15.ch.Ctor
8614inline algo::RnullStr15::RnullStr15(const algo::RnullStr15 &rhs) {
8615 operator =(rhs);
8616}
8617
8618// --- algo.RnullStr15.ch.CtorStrptr
8619inline algo::RnullStr15::RnullStr15(const algo::strptr &rhs) {
8620 ch_SetStrptr(*this, rhs);
8621}
8622
8623// --- algo.RnullStr15.ch.Cast
8624inline algo::RnullStr15::operator algo::strptr () const {
8625 return ch_Getary(*this);
8626}
8627
8628// --- algo.RnullStr15..Lt
8629inline bool algo::RnullStr15_Lt(algo::RnullStr15& lhs, algo::RnullStr15& rhs) {
8630 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
8631}
8632
8633// --- algo.RnullStr15..Cmp
8634inline i32 algo::RnullStr15_Cmp(algo::RnullStr15& lhs, algo::RnullStr15& rhs) {
8635 i32 retval = 0;
8636 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
8637 return retval;
8638}
8639
8640// --- algo.RnullStr15..Init
8641// Set all fields to initial values.
8642inline void algo::RnullStr15_Init(algo::RnullStr15& parent) {
8643 memset(parent.ch, 0, 15);
8644}
8645
8646// --- algo.RnullStr15..Eq
8647inline bool algo::RnullStr15_Eq(algo::RnullStr15& lhs, algo::RnullStr15& rhs) {
8648 bool retval = true;
8649 retval = retval
8650 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
8651 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
8652 &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12)
8653 &&*(u8*)(lhs.ch+14) == *(u8*)(rhs.ch+14);
8654 return retval;
8655}
8656
8657// --- algo.RnullStr15..Update
8658// Set value. Return true if new value is different from old value.
8659inline bool algo::RnullStr15_Update(algo::RnullStr15 &lhs, algo::RnullStr15& rhs) {
8660 bool ret = !RnullStr15_Eq(lhs, rhs); // compare values
8661 if (ret) {
8662 lhs = rhs; // update
8663 }
8664 return ret;
8665}
8666
8667// --- algo.RnullStr15..EqStrptr
8668inline bool algo::RnullStr15_EqStrptr(const algo::RnullStr15& lhs, const algo::strptr& rhs) {
8669 return algo::strptr_Eq(ch_Getary(lhs), rhs);
8670}
8671
8672inline bool algo::RnullStr151::operator ==(const algo::RnullStr151 &rhs) const {
8673 return algo::RnullStr151_Eq(const_cast<algo::RnullStr151&>(*this),const_cast<algo::RnullStr151&>(rhs));
8674}
8675
8676inline bool algo::RnullStr151::operator !=(const algo::RnullStr151 &rhs) const {
8677 return !algo::RnullStr151_Eq(const_cast<algo::RnullStr151&>(*this),const_cast<algo::RnullStr151&>(rhs));
8678}
8679
8680inline bool algo::RnullStr151::operator ==(const algo::strptr &rhs) const {
8681 return algo::RnullStr151_EqStrptr(const_cast<algo::RnullStr151&>(*this),rhs);
8682}
8683
8684inline bool algo::RnullStr151::operator <(const algo::RnullStr151 &rhs) const {
8685 return algo::RnullStr151_Lt(const_cast<algo::RnullStr151&>(*this),const_cast<algo::RnullStr151&>(rhs));
8686}
8687
8688inline bool algo::RnullStr151::operator >(const algo::RnullStr151 &rhs) const {
8689 return rhs < *this;
8690}
8691
8692inline bool algo::RnullStr151::operator <=(const algo::RnullStr151 &rhs) const {
8693 return !(rhs < *this);
8694}
8695
8696inline bool algo::RnullStr151::operator >=(const algo::RnullStr151 &rhs) const {
8697 return !(*this < rhs);
8698}
8699inline algo::RnullStr151::RnullStr151() {
8700 algo::RnullStr151_Init(*this);
8701}
8702
8703
8704// --- algo.RnullStr151.ch.Getary
8705// Access string as array of chars
8706inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr151& parent) {
8707 int len = ch_N(parent);
8708 algo::aryptr<char> ret((char*)parent.ch, len);
8709 return ret;
8710}
8711
8712// --- algo.RnullStr151.ch.HashStrptr
8713inline u32 algo::RnullStr151_Hash(u32 prev, const algo::strptr &str) {
8714 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
8715}
8716
8717// --- algo.RnullStr151.ch.Init
8718inline void algo::ch_Init(algo::RnullStr151 &parent) {
8719 memset(parent.ch, 0, 151);
8720}
8721
8722// --- algo.RnullStr151.ch.Max
8723// always return constant 151
8724inline int algo::ch_Max(algo::RnullStr151& parent) {
8725 (void)parent;
8726 return 151;
8727}
8728
8729// --- algo.RnullStr151.ch.N
8730inline int algo::ch_N(const algo::RnullStr151& parent) {
8731 u64 ret;
8732 ret = 151;
8733 while (ret>0 && parent.ch[ret-1]==u8(0)) {
8734 ret--;
8735 }
8736 return int(ret);
8737}
8738
8739// --- algo.RnullStr151.ch.AssignStrptr
8740// Copy from strptr (operator=)
8741inline void algo::RnullStr151::operator =(const algo::strptr &str) {
8742 ch_SetStrptr(*this, str);
8743}
8744
8745// --- algo.RnullStr151.ch.Set
8746// Copy from same type
8747// Copy value from RHS.
8748inline void algo::RnullStr151::operator =(const algo::RnullStr151& parent) {
8749 memcpy(ch, parent.ch, 151);
8750}
8751
8752// --- algo.RnullStr151.ch.Ctor
8753inline algo::RnullStr151::RnullStr151(const algo::RnullStr151 &rhs) {
8754 operator =(rhs);
8755}
8756
8757// --- algo.RnullStr151.ch.CtorStrptr
8758inline algo::RnullStr151::RnullStr151(const algo::strptr &rhs) {
8759 ch_SetStrptr(*this, rhs);
8760}
8761
8762// --- algo.RnullStr151.ch.Cast
8763inline algo::RnullStr151::operator algo::strptr () const {
8764 return ch_Getary(*this);
8765}
8766
8767// --- algo.RnullStr151..Lt
8768inline bool algo::RnullStr151_Lt(algo::RnullStr151& lhs, algo::RnullStr151& rhs) {
8769 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
8770}
8771
8772// --- algo.RnullStr151..Cmp
8773inline i32 algo::RnullStr151_Cmp(algo::RnullStr151& lhs, algo::RnullStr151& rhs) {
8774 i32 retval = 0;
8775 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
8776 return retval;
8777}
8778
8779// --- algo.RnullStr151..Init
8780// Set all fields to initial values.
8781inline void algo::RnullStr151_Init(algo::RnullStr151& parent) {
8782 memset(parent.ch, 0, 151);
8783}
8784
8785// --- algo.RnullStr151..Eq
8786inline bool algo::RnullStr151_Eq(algo::RnullStr151& lhs, algo::RnullStr151& rhs) {
8787 bool retval = true;
8788 for (int i=0; i<18 && retval; i++) {
8789 retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
8790 }
8791 retval = retval
8792 &&*(u32*)(lhs.ch+144) == *(u32*)(rhs.ch+144)
8793 &&*(u16*)(lhs.ch+148) == *(u16*)(rhs.ch+148)
8794 &&*(u8*)(lhs.ch+150) == *(u8*)(rhs.ch+150);
8795 return retval;
8796}
8797
8798// --- algo.RnullStr151..Update
8799// Set value. Return true if new value is different from old value.
8800inline bool algo::RnullStr151_Update(algo::RnullStr151 &lhs, algo::RnullStr151& rhs) {
8801 bool ret = !RnullStr151_Eq(lhs, rhs); // compare values
8802 if (ret) {
8803 lhs = rhs; // update
8804 }
8805 return ret;
8806}
8807
8808// --- algo.RnullStr151..EqStrptr
8809inline bool algo::RnullStr151_EqStrptr(const algo::RnullStr151& lhs, const algo::strptr& rhs) {
8810 return algo::strptr_Eq(ch_Getary(lhs), rhs);
8811}
8812inline algo::RnullStr16::RnullStr16() {
8813 algo::RnullStr16_Init(*this);
8814}
8815
8816
8817// --- algo.RnullStr16.ch.Getary
8818// Access string as array of chars
8819inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr16& parent) {
8820 int len = ch_N(parent);
8821 algo::aryptr<char> ret((char*)parent.ch, len);
8822 return ret;
8823}
8824
8825// --- algo.RnullStr16.ch.HashStrptr
8826inline u32 algo::RnullStr16_Hash(u32 prev, const algo::strptr &str) {
8827 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
8828}
8829
8830// --- algo.RnullStr16.ch.Init
8831inline void algo::ch_Init(algo::RnullStr16 &parent) {
8832 memset(parent.ch, 0, 16);
8833}
8834
8835// --- algo.RnullStr16.ch.Max
8836// always return constant 16
8837inline int algo::ch_Max(algo::RnullStr16& parent) {
8838 (void)parent;
8839 return 16;
8840}
8841
8842// --- algo.RnullStr16.ch.N
8843inline int algo::ch_N(const algo::RnullStr16& parent) {
8844 u64 ret;
8845 ret = 16;
8846 while (ret>0 && parent.ch[ret-1]==u8(0)) {
8847 ret--;
8848 }
8849 return int(ret);
8850}
8851
8852// --- algo.RnullStr16.ch.AssignStrptr
8853// Copy from strptr (operator=)
8854inline void algo::RnullStr16::operator =(const algo::strptr &str) {
8855 ch_SetStrptr(*this, str);
8856}
8857
8858// --- algo.RnullStr16.ch.Set
8859// Copy from same type
8860// Copy value from RHS.
8861inline void algo::RnullStr16::operator =(const algo::RnullStr16& parent) {
8862 memcpy(ch, parent.ch, 16);
8863}
8864
8865// --- algo.RnullStr16.ch.Ctor
8866inline algo::RnullStr16::RnullStr16(const algo::RnullStr16 &rhs) {
8867 operator =(rhs);
8868}
8869
8870// --- algo.RnullStr16.ch.CtorStrptr
8871inline algo::RnullStr16::RnullStr16(const algo::strptr &rhs) {
8872 ch_SetStrptr(*this, rhs);
8873}
8874
8875// --- algo.RnullStr16.ch.Cast
8876inline algo::RnullStr16::operator algo::strptr () const {
8877 return ch_Getary(*this);
8878}
8879
8880// --- algo.RnullStr16..Lt
8881inline bool algo::RnullStr16_Lt(algo::RnullStr16 lhs, algo::RnullStr16 rhs) {
8882 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
8883}
8884
8885// --- algo.RnullStr16..Cmp
8886inline i32 algo::RnullStr16_Cmp(algo::RnullStr16 lhs, algo::RnullStr16 rhs) {
8887 i32 retval = 0;
8888 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
8889 return retval;
8890}
8891
8892// --- algo.RnullStr16..Init
8893// Set all fields to initial values.
8894inline void algo::RnullStr16_Init(algo::RnullStr16& parent) {
8895 memset(parent.ch, 0, 16);
8896}
8897
8898// --- algo.RnullStr16..Eq
8899inline bool algo::RnullStr16_Eq(algo::RnullStr16 lhs, algo::RnullStr16 rhs) {
8900 bool retval = true;
8901 retval = retval
8902 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
8903 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8);
8904 return retval;
8905}
8906
8907// --- algo.RnullStr16..Update
8908// Set value. Return true if new value is different from old value.
8909inline bool algo::RnullStr16_Update(algo::RnullStr16 &lhs, algo::RnullStr16 rhs) {
8910 bool ret = !RnullStr16_Eq(lhs, rhs); // compare values
8911 if (ret) {
8912 lhs = rhs; // update
8913 }
8914 return ret;
8915}
8916
8917// --- algo.RnullStr16..EqStrptr
8918inline bool algo::RnullStr16_EqStrptr(algo::RnullStr16 lhs, const algo::strptr& rhs) {
8919 return algo::strptr_Eq(ch_Getary(lhs), rhs);
8920}
8921
8922inline bool algo::RnullStr17::operator ==(const algo::RnullStr17 &rhs) const {
8923 return algo::RnullStr17_Eq(const_cast<algo::RnullStr17&>(*this),const_cast<algo::RnullStr17&>(rhs));
8924}
8925
8926inline bool algo::RnullStr17::operator !=(const algo::RnullStr17 &rhs) const {
8927 return !algo::RnullStr17_Eq(const_cast<algo::RnullStr17&>(*this),const_cast<algo::RnullStr17&>(rhs));
8928}
8929
8930inline bool algo::RnullStr17::operator ==(const algo::strptr &rhs) const {
8931 return algo::RnullStr17_EqStrptr(const_cast<algo::RnullStr17&>(*this),rhs);
8932}
8933
8934inline bool algo::RnullStr17::operator <(const algo::RnullStr17 &rhs) const {
8935 return algo::RnullStr17_Lt(const_cast<algo::RnullStr17&>(*this),const_cast<algo::RnullStr17&>(rhs));
8936}
8937
8938inline bool algo::RnullStr17::operator >(const algo::RnullStr17 &rhs) const {
8939 return rhs < *this;
8940}
8941
8942inline bool algo::RnullStr17::operator <=(const algo::RnullStr17 &rhs) const {
8943 return !(rhs < *this);
8944}
8945
8946inline bool algo::RnullStr17::operator >=(const algo::RnullStr17 &rhs) const {
8947 return !(*this < rhs);
8948}
8949inline algo::RnullStr17::RnullStr17() {
8950 algo::RnullStr17_Init(*this);
8951}
8952
8953
8954// --- algo.RnullStr17.ch.Getary
8955// Access string as array of chars
8956inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr17& parent) {
8957 int len = ch_N(parent);
8958 algo::aryptr<char> ret((char*)parent.ch, len);
8959 return ret;
8960}
8961
8962// --- algo.RnullStr17.ch.HashStrptr
8963inline u32 algo::RnullStr17_Hash(u32 prev, const algo::strptr &str) {
8964 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
8965}
8966
8967// --- algo.RnullStr17.ch.Init
8968inline void algo::ch_Init(algo::RnullStr17 &parent) {
8969 memset(parent.ch, 0, 17);
8970}
8971
8972// --- algo.RnullStr17.ch.Max
8973// always return constant 17
8974inline int algo::ch_Max(algo::RnullStr17& parent) {
8975 (void)parent;
8976 return 17;
8977}
8978
8979// --- algo.RnullStr17.ch.N
8980inline int algo::ch_N(const algo::RnullStr17& parent) {
8981 u64 ret;
8982 ret = 17;
8983 while (ret>0 && parent.ch[ret-1]==u8(0)) {
8984 ret--;
8985 }
8986 return int(ret);
8987}
8988
8989// --- algo.RnullStr17.ch.AssignStrptr
8990// Copy from strptr (operator=)
8991inline void algo::RnullStr17::operator =(const algo::strptr &str) {
8992 ch_SetStrptr(*this, str);
8993}
8994
8995// --- algo.RnullStr17.ch.Set
8996// Copy from same type
8997// Copy value from RHS.
8998inline void algo::RnullStr17::operator =(const algo::RnullStr17& parent) {
8999 memcpy(ch, parent.ch, 17);
9000}
9001
9002// --- algo.RnullStr17.ch.Ctor
9003inline algo::RnullStr17::RnullStr17(const algo::RnullStr17 &rhs) {
9004 operator =(rhs);
9005}
9006
9007// --- algo.RnullStr17.ch.CtorStrptr
9008inline algo::RnullStr17::RnullStr17(const algo::strptr &rhs) {
9009 ch_SetStrptr(*this, rhs);
9010}
9011
9012// --- algo.RnullStr17.ch.Cast
9013inline algo::RnullStr17::operator algo::strptr () const {
9014 return ch_Getary(*this);
9015}
9016
9017// --- algo.RnullStr17..Lt
9018inline bool algo::RnullStr17_Lt(algo::RnullStr17& lhs, algo::RnullStr17& rhs) {
9019 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
9020}
9021
9022// --- algo.RnullStr17..Cmp
9023inline i32 algo::RnullStr17_Cmp(algo::RnullStr17& lhs, algo::RnullStr17& rhs) {
9024 i32 retval = 0;
9025 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
9026 return retval;
9027}
9028
9029// --- algo.RnullStr17..Init
9030// Set all fields to initial values.
9031inline void algo::RnullStr17_Init(algo::RnullStr17& parent) {
9032 memset(parent.ch, 0, 17);
9033}
9034
9035// --- algo.RnullStr17..Eq
9036inline bool algo::RnullStr17_Eq(algo::RnullStr17& lhs, algo::RnullStr17& rhs) {
9037 bool retval = true;
9038 retval = retval
9039 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
9040 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
9041 &&*(u8*)(lhs.ch+16) == *(u8*)(rhs.ch+16);
9042 return retval;
9043}
9044
9045// --- algo.RnullStr17..Update
9046// Set value. Return true if new value is different from old value.
9047inline bool algo::RnullStr17_Update(algo::RnullStr17 &lhs, algo::RnullStr17& rhs) {
9048 bool ret = !RnullStr17_Eq(lhs, rhs); // compare values
9049 if (ret) {
9050 lhs = rhs; // update
9051 }
9052 return ret;
9053}
9054
9055// --- algo.RnullStr17..EqStrptr
9056inline bool algo::RnullStr17_EqStrptr(const algo::RnullStr17& lhs, const algo::strptr& rhs) {
9057 return algo::strptr_Eq(ch_Getary(lhs), rhs);
9058}
9059
9060inline bool algo::RnullStr18::operator ==(const algo::RnullStr18 &rhs) const {
9061 return algo::RnullStr18_Eq(const_cast<algo::RnullStr18&>(*this),const_cast<algo::RnullStr18&>(rhs));
9062}
9063
9064inline bool algo::RnullStr18::operator !=(const algo::RnullStr18 &rhs) const {
9065 return !algo::RnullStr18_Eq(const_cast<algo::RnullStr18&>(*this),const_cast<algo::RnullStr18&>(rhs));
9066}
9067
9068inline bool algo::RnullStr18::operator ==(const algo::strptr &rhs) const {
9069 return algo::RnullStr18_EqStrptr(const_cast<algo::RnullStr18&>(*this),rhs);
9070}
9071
9072inline bool algo::RnullStr18::operator <(const algo::RnullStr18 &rhs) const {
9073 return algo::RnullStr18_Lt(const_cast<algo::RnullStr18&>(*this),const_cast<algo::RnullStr18&>(rhs));
9074}
9075
9076inline bool algo::RnullStr18::operator >(const algo::RnullStr18 &rhs) const {
9077 return rhs < *this;
9078}
9079
9080inline bool algo::RnullStr18::operator <=(const algo::RnullStr18 &rhs) const {
9081 return !(rhs < *this);
9082}
9083
9084inline bool algo::RnullStr18::operator >=(const algo::RnullStr18 &rhs) const {
9085 return !(*this < rhs);
9086}
9087inline algo::RnullStr18::RnullStr18() {
9088 algo::RnullStr18_Init(*this);
9089}
9090
9091
9092// --- algo.RnullStr18.ch.Getary
9093// Access string as array of chars
9094inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr18& parent) {
9095 int len = ch_N(parent);
9096 algo::aryptr<char> ret((char*)parent.ch, len);
9097 return ret;
9098}
9099
9100// --- algo.RnullStr18.ch.HashStrptr
9101inline u32 algo::RnullStr18_Hash(u32 prev, const algo::strptr &str) {
9102 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
9103}
9104
9105// --- algo.RnullStr18.ch.Init
9106inline void algo::ch_Init(algo::RnullStr18 &parent) {
9107 memset(parent.ch, 0, 18);
9108}
9109
9110// --- algo.RnullStr18.ch.Max
9111// always return constant 18
9112inline int algo::ch_Max(algo::RnullStr18& parent) {
9113 (void)parent;
9114 return 18;
9115}
9116
9117// --- algo.RnullStr18.ch.N
9118inline int algo::ch_N(const algo::RnullStr18& parent) {
9119 u64 ret;
9120 ret = 18;
9121 while (ret>0 && parent.ch[ret-1]==u8(0)) {
9122 ret--;
9123 }
9124 return int(ret);
9125}
9126
9127// --- algo.RnullStr18.ch.AssignStrptr
9128// Copy from strptr (operator=)
9129inline void algo::RnullStr18::operator =(const algo::strptr &str) {
9130 ch_SetStrptr(*this, str);
9131}
9132
9133// --- algo.RnullStr18.ch.Set
9134// Copy from same type
9135// Copy value from RHS.
9136inline void algo::RnullStr18::operator =(const algo::RnullStr18& parent) {
9137 memcpy(ch, parent.ch, 18);
9138}
9139
9140// --- algo.RnullStr18.ch.Ctor
9141inline algo::RnullStr18::RnullStr18(const algo::RnullStr18 &rhs) {
9142 operator =(rhs);
9143}
9144
9145// --- algo.RnullStr18.ch.CtorStrptr
9146inline algo::RnullStr18::RnullStr18(const algo::strptr &rhs) {
9147 ch_SetStrptr(*this, rhs);
9148}
9149
9150// --- algo.RnullStr18.ch.Cast
9151inline algo::RnullStr18::operator algo::strptr () const {
9152 return ch_Getary(*this);
9153}
9154
9155// --- algo.RnullStr18..Lt
9156inline bool algo::RnullStr18_Lt(algo::RnullStr18 lhs, algo::RnullStr18 rhs) {
9157 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
9158}
9159
9160// --- algo.RnullStr18..Cmp
9161inline i32 algo::RnullStr18_Cmp(algo::RnullStr18 lhs, algo::RnullStr18 rhs) {
9162 i32 retval = 0;
9163 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
9164 return retval;
9165}
9166
9167// --- algo.RnullStr18..Init
9168// Set all fields to initial values.
9169inline void algo::RnullStr18_Init(algo::RnullStr18& parent) {
9170 memset(parent.ch, 0, 18);
9171}
9172
9173// --- algo.RnullStr18..Eq
9174inline bool algo::RnullStr18_Eq(algo::RnullStr18 lhs, algo::RnullStr18 rhs) {
9175 bool retval = true;
9176 retval = retval
9177 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
9178 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
9179 &&*(u16*)(lhs.ch+16) == *(u16*)(rhs.ch+16);
9180 return retval;
9181}
9182
9183// --- algo.RnullStr18..Update
9184// Set value. Return true if new value is different from old value.
9185inline bool algo::RnullStr18_Update(algo::RnullStr18 &lhs, algo::RnullStr18 rhs) {
9186 bool ret = !RnullStr18_Eq(lhs, rhs); // compare values
9187 if (ret) {
9188 lhs = rhs; // update
9189 }
9190 return ret;
9191}
9192
9193// --- algo.RnullStr18..EqStrptr
9194inline bool algo::RnullStr18_EqStrptr(algo::RnullStr18 lhs, const algo::strptr& rhs) {
9195 return algo::strptr_Eq(ch_Getary(lhs), rhs);
9196}
9197inline algo::RnullStr19::RnullStr19() {
9198 algo::RnullStr19_Init(*this);
9199}
9200
9201
9202// --- algo.RnullStr19.ch.Getary
9203// Access string as array of chars
9204inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr19& parent) {
9205 int len = ch_N(parent);
9206 algo::aryptr<char> ret((char*)parent.ch, len);
9207 return ret;
9208}
9209
9210// --- algo.RnullStr19.ch.HashStrptr
9211inline u32 algo::RnullStr19_Hash(u32 prev, const algo::strptr &str) {
9212 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
9213}
9214
9215// --- algo.RnullStr19.ch.Init
9216inline void algo::ch_Init(algo::RnullStr19 &parent) {
9217 memset(parent.ch, 0, 19);
9218}
9219
9220// --- algo.RnullStr19.ch.Max
9221// always return constant 19
9222inline int algo::ch_Max(algo::RnullStr19& parent) {
9223 (void)parent;
9224 return 19;
9225}
9226
9227// --- algo.RnullStr19.ch.N
9228inline int algo::ch_N(const algo::RnullStr19& parent) {
9229 u64 ret;
9230 ret = 19;
9231 while (ret>0 && parent.ch[ret-1]==u8(0)) {
9232 ret--;
9233 }
9234 return int(ret);
9235}
9236
9237// --- algo.RnullStr19.ch.AssignStrptr
9238// Copy from strptr (operator=)
9239inline void algo::RnullStr19::operator =(const algo::strptr &str) {
9240 ch_SetStrptr(*this, str);
9241}
9242
9243// --- algo.RnullStr19.ch.Set
9244// Copy from same type
9245// Copy value from RHS.
9246inline void algo::RnullStr19::operator =(const algo::RnullStr19& parent) {
9247 memcpy(ch, parent.ch, 19);
9248}
9249
9250// --- algo.RnullStr19.ch.Ctor
9251inline algo::RnullStr19::RnullStr19(const algo::RnullStr19 &rhs) {
9252 operator =(rhs);
9253}
9254
9255// --- algo.RnullStr19.ch.CtorStrptr
9256inline algo::RnullStr19::RnullStr19(const algo::strptr &rhs) {
9257 ch_SetStrptr(*this, rhs);
9258}
9259
9260// --- algo.RnullStr19.ch.Cast
9261inline algo::RnullStr19::operator algo::strptr () const {
9262 return ch_Getary(*this);
9263}
9264
9265// --- algo.RnullStr19..Lt
9266inline bool algo::RnullStr19_Lt(algo::RnullStr19& lhs, algo::RnullStr19& rhs) {
9267 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
9268}
9269
9270// --- algo.RnullStr19..Cmp
9271inline i32 algo::RnullStr19_Cmp(algo::RnullStr19& lhs, algo::RnullStr19& rhs) {
9272 i32 retval = 0;
9273 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
9274 return retval;
9275}
9276
9277// --- algo.RnullStr19..Init
9278// Set all fields to initial values.
9279inline void algo::RnullStr19_Init(algo::RnullStr19& parent) {
9280 memset(parent.ch, 0, 19);
9281}
9282
9283// --- algo.RnullStr19..Eq
9284inline bool algo::RnullStr19_Eq(algo::RnullStr19& lhs, algo::RnullStr19& rhs) {
9285 bool retval = true;
9286 retval = retval
9287 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
9288 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
9289 &&*(u16*)(lhs.ch+16) == *(u16*)(rhs.ch+16)
9290 &&*(u8*)(lhs.ch+18) == *(u8*)(rhs.ch+18);
9291 return retval;
9292}
9293
9294// --- algo.RnullStr19..Update
9295// Set value. Return true if new value is different from old value.
9296inline bool algo::RnullStr19_Update(algo::RnullStr19 &lhs, algo::RnullStr19& rhs) {
9297 bool ret = !RnullStr19_Eq(lhs, rhs); // compare values
9298 if (ret) {
9299 lhs = rhs; // update
9300 }
9301 return ret;
9302}
9303
9304// --- algo.RnullStr19..EqStrptr
9305inline bool algo::RnullStr19_EqStrptr(const algo::RnullStr19& lhs, const algo::strptr& rhs) {
9306 return algo::strptr_Eq(ch_Getary(lhs), rhs);
9307}
9308
9309inline bool algo::RnullStr2::operator ==(const algo::RnullStr2 &rhs) const {
9310 return algo::RnullStr2_Eq(const_cast<algo::RnullStr2&>(*this),const_cast<algo::RnullStr2&>(rhs));
9311}
9312
9313inline bool algo::RnullStr2::operator !=(const algo::RnullStr2 &rhs) const {
9314 return !algo::RnullStr2_Eq(const_cast<algo::RnullStr2&>(*this),const_cast<algo::RnullStr2&>(rhs));
9315}
9316
9317inline bool algo::RnullStr2::operator ==(const algo::strptr &rhs) const {
9318 return algo::RnullStr2_EqStrptr(const_cast<algo::RnullStr2&>(*this),rhs);
9319}
9320
9321inline bool algo::RnullStr2::operator <(const algo::RnullStr2 &rhs) const {
9322 return algo::RnullStr2_Lt(const_cast<algo::RnullStr2&>(*this),const_cast<algo::RnullStr2&>(rhs));
9323}
9324
9325inline bool algo::RnullStr2::operator >(const algo::RnullStr2 &rhs) const {
9326 return rhs < *this;
9327}
9328
9329inline bool algo::RnullStr2::operator <=(const algo::RnullStr2 &rhs) const {
9330 return !(rhs < *this);
9331}
9332
9333inline bool algo::RnullStr2::operator >=(const algo::RnullStr2 &rhs) const {
9334 return !(*this < rhs);
9335}
9336inline algo::RnullStr2::RnullStr2() {
9337 algo::RnullStr2_Init(*this);
9338}
9339
9340
9341// --- algo.RnullStr2.ch.Getary
9342// Access string as array of chars
9343inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr2& parent) {
9344 int len = ch_N(parent);
9345 algo::aryptr<char> ret((char*)parent.ch, len);
9346 return ret;
9347}
9348
9349// --- algo.RnullStr2.ch.HashStrptr
9350inline u32 algo::RnullStr2_Hash(u32 prev, const algo::strptr &str) {
9351 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
9352}
9353
9354// --- algo.RnullStr2.ch.Init
9355inline void algo::ch_Init(algo::RnullStr2 &parent) {
9356 memset(parent.ch, 0, 2);
9357}
9358
9359// --- algo.RnullStr2.ch.Max
9360// always return constant 2
9361inline int algo::ch_Max(algo::RnullStr2& parent) {
9362 (void)parent;
9363 return 2;
9364}
9365
9366// --- algo.RnullStr2.ch.N
9367inline int algo::ch_N(const algo::RnullStr2& parent) {
9368 u64 ret;
9369 ret = 2;
9370 while (ret>0 && parent.ch[ret-1]==u8(0)) {
9371 ret--;
9372 }
9373 return int(ret);
9374}
9375
9376// --- algo.RnullStr2.ch.AssignStrptr
9377// Copy from strptr (operator=)
9378inline void algo::RnullStr2::operator =(const algo::strptr &str) {
9379 ch_SetStrptr(*this, str);
9380}
9381
9382// --- algo.RnullStr2.ch.Set
9383// Copy from same type
9384// Copy value from RHS.
9385inline void algo::RnullStr2::operator =(const algo::RnullStr2& parent) {
9386 memcpy(ch, parent.ch, 2);
9387}
9388
9389// --- algo.RnullStr2.ch.Ctor
9390inline algo::RnullStr2::RnullStr2(const algo::RnullStr2 &rhs) {
9391 operator =(rhs);
9392}
9393
9394// --- algo.RnullStr2.ch.CtorStrptr
9395inline algo::RnullStr2::RnullStr2(const algo::strptr &rhs) {
9396 ch_SetStrptr(*this, rhs);
9397}
9398
9399// --- algo.RnullStr2.ch.Cast
9400inline algo::RnullStr2::operator algo::strptr () const {
9401 return ch_Getary(*this);
9402}
9403
9404// --- algo.RnullStr2..Lt
9405inline bool algo::RnullStr2_Lt(algo::RnullStr2 lhs, algo::RnullStr2 rhs) {
9406 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
9407}
9408
9409// --- algo.RnullStr2..Cmp
9410inline i32 algo::RnullStr2_Cmp(algo::RnullStr2 lhs, algo::RnullStr2 rhs) {
9411 i32 retval = 0;
9412 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
9413 return retval;
9414}
9415
9416// --- algo.RnullStr2..Init
9417// Set all fields to initial values.
9418inline void algo::RnullStr2_Init(algo::RnullStr2& parent) {
9419 memset(parent.ch, 0, 2);
9420}
9421
9422// --- algo.RnullStr2..Eq
9423inline bool algo::RnullStr2_Eq(algo::RnullStr2 lhs, algo::RnullStr2 rhs) {
9424 bool retval = true;
9425 retval = retval
9426 &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0);
9427 return retval;
9428}
9429
9430// --- algo.RnullStr2..Update
9431// Set value. Return true if new value is different from old value.
9432inline bool algo::RnullStr2_Update(algo::RnullStr2 &lhs, algo::RnullStr2 rhs) {
9433 bool ret = !RnullStr2_Eq(lhs, rhs); // compare values
9434 if (ret) {
9435 lhs = rhs; // update
9436 }
9437 return ret;
9438}
9439
9440// --- algo.RnullStr2..EqStrptr
9441inline bool algo::RnullStr2_EqStrptr(algo::RnullStr2 lhs, const algo::strptr& rhs) {
9442 return algo::strptr_Eq(ch_Getary(lhs), rhs);
9443}
9444
9445inline bool algo::RnullStr20::operator ==(const algo::RnullStr20 &rhs) const {
9446 return algo::RnullStr20_Eq(const_cast<algo::RnullStr20&>(*this),const_cast<algo::RnullStr20&>(rhs));
9447}
9448
9449inline bool algo::RnullStr20::operator !=(const algo::RnullStr20 &rhs) const {
9450 return !algo::RnullStr20_Eq(const_cast<algo::RnullStr20&>(*this),const_cast<algo::RnullStr20&>(rhs));
9451}
9452
9453inline bool algo::RnullStr20::operator ==(const algo::strptr &rhs) const {
9454 return algo::RnullStr20_EqStrptr(const_cast<algo::RnullStr20&>(*this),rhs);
9455}
9456
9457inline bool algo::RnullStr20::operator <(const algo::RnullStr20 &rhs) const {
9458 return algo::RnullStr20_Lt(const_cast<algo::RnullStr20&>(*this),const_cast<algo::RnullStr20&>(rhs));
9459}
9460
9461inline bool algo::RnullStr20::operator >(const algo::RnullStr20 &rhs) const {
9462 return rhs < *this;
9463}
9464
9465inline bool algo::RnullStr20::operator <=(const algo::RnullStr20 &rhs) const {
9466 return !(rhs < *this);
9467}
9468
9469inline bool algo::RnullStr20::operator >=(const algo::RnullStr20 &rhs) const {
9470 return !(*this < rhs);
9471}
9472inline algo::RnullStr20::RnullStr20() {
9473 algo::RnullStr20_Init(*this);
9474}
9475
9476
9477// --- algo.RnullStr20.ch.Getary
9478// Access string as array of chars
9479inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr20& parent) {
9480 int len = ch_N(parent);
9481 algo::aryptr<char> ret((char*)parent.ch, len);
9482 return ret;
9483}
9484
9485// --- algo.RnullStr20.ch.HashStrptr
9486inline u32 algo::RnullStr20_Hash(u32 prev, const algo::strptr &str) {
9487 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
9488}
9489
9490// --- algo.RnullStr20.ch.Init
9491inline void algo::ch_Init(algo::RnullStr20 &parent) {
9492 memset(parent.ch, 0, 20);
9493}
9494
9495// --- algo.RnullStr20.ch.Max
9496// always return constant 20
9497inline int algo::ch_Max(algo::RnullStr20& parent) {
9498 (void)parent;
9499 return 20;
9500}
9501
9502// --- algo.RnullStr20.ch.N
9503inline int algo::ch_N(const algo::RnullStr20& parent) {
9504 u64 ret;
9505 ret = 20;
9506 while (ret>0 && parent.ch[ret-1]==u8(0)) {
9507 ret--;
9508 }
9509 return int(ret);
9510}
9511
9512// --- algo.RnullStr20.ch.AssignStrptr
9513// Copy from strptr (operator=)
9514inline void algo::RnullStr20::operator =(const algo::strptr &str) {
9515 ch_SetStrptr(*this, str);
9516}
9517
9518// --- algo.RnullStr20.ch.Set
9519// Copy from same type
9520// Copy value from RHS.
9521inline void algo::RnullStr20::operator =(const algo::RnullStr20& parent) {
9522 memcpy(ch, parent.ch, 20);
9523}
9524
9525// --- algo.RnullStr20.ch.Ctor
9526inline algo::RnullStr20::RnullStr20(const algo::RnullStr20 &rhs) {
9527 operator =(rhs);
9528}
9529
9530// --- algo.RnullStr20.ch.CtorStrptr
9531inline algo::RnullStr20::RnullStr20(const algo::strptr &rhs) {
9532 ch_SetStrptr(*this, rhs);
9533}
9534
9535// --- algo.RnullStr20.ch.Cast
9536inline algo::RnullStr20::operator algo::strptr () const {
9537 return ch_Getary(*this);
9538}
9539
9540// --- algo.RnullStr20..Lt
9541inline bool algo::RnullStr20_Lt(algo::RnullStr20 lhs, algo::RnullStr20 rhs) {
9542 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
9543}
9544
9545// --- algo.RnullStr20..Cmp
9546inline i32 algo::RnullStr20_Cmp(algo::RnullStr20 lhs, algo::RnullStr20 rhs) {
9547 i32 retval = 0;
9548 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
9549 return retval;
9550}
9551
9552// --- algo.RnullStr20..Init
9553// Set all fields to initial values.
9554inline void algo::RnullStr20_Init(algo::RnullStr20& parent) {
9555 memset(parent.ch, 0, 20);
9556}
9557
9558// --- algo.RnullStr20..Eq
9559inline bool algo::RnullStr20_Eq(algo::RnullStr20 lhs, algo::RnullStr20 rhs) {
9560 bool retval = true;
9561 retval = retval
9562 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
9563 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
9564 &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
9565 return retval;
9566}
9567
9568// --- algo.RnullStr20..Update
9569// Set value. Return true if new value is different from old value.
9570inline bool algo::RnullStr20_Update(algo::RnullStr20 &lhs, algo::RnullStr20 rhs) {
9571 bool ret = !RnullStr20_Eq(lhs, rhs); // compare values
9572 if (ret) {
9573 lhs = rhs; // update
9574 }
9575 return ret;
9576}
9577
9578// --- algo.RnullStr20..EqStrptr
9579inline bool algo::RnullStr20_EqStrptr(algo::RnullStr20 lhs, const algo::strptr& rhs) {
9580 return algo::strptr_Eq(ch_Getary(lhs), rhs);
9581}
9582inline algo::RnullStr21::RnullStr21() {
9583 algo::RnullStr21_Init(*this);
9584}
9585
9586
9587// --- algo.RnullStr21.ch.Getary
9588// Access string as array of chars
9589inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr21& parent) {
9590 int len = ch_N(parent);
9591 algo::aryptr<char> ret((char*)parent.ch, len);
9592 return ret;
9593}
9594
9595// --- algo.RnullStr21.ch.HashStrptr
9596inline u32 algo::RnullStr21_Hash(u32 prev, const algo::strptr &str) {
9597 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
9598}
9599
9600// --- algo.RnullStr21.ch.Init
9601inline void algo::ch_Init(algo::RnullStr21 &parent) {
9602 memset(parent.ch, 0, 21);
9603}
9604
9605// --- algo.RnullStr21.ch.Max
9606// always return constant 21
9607inline int algo::ch_Max(algo::RnullStr21& parent) {
9608 (void)parent;
9609 return 21;
9610}
9611
9612// --- algo.RnullStr21.ch.N
9613inline int algo::ch_N(const algo::RnullStr21& parent) {
9614 u64 ret;
9615 ret = 21;
9616 while (ret>0 && parent.ch[ret-1]==u8(0)) {
9617 ret--;
9618 }
9619 return int(ret);
9620}
9621
9622// --- algo.RnullStr21.ch.AssignStrptr
9623// Copy from strptr (operator=)
9624inline void algo::RnullStr21::operator =(const algo::strptr &str) {
9625 ch_SetStrptr(*this, str);
9626}
9627
9628// --- algo.RnullStr21.ch.Set
9629// Copy from same type
9630// Copy value from RHS.
9631inline void algo::RnullStr21::operator =(const algo::RnullStr21& parent) {
9632 memcpy(ch, parent.ch, 21);
9633}
9634
9635// --- algo.RnullStr21.ch.Ctor
9636inline algo::RnullStr21::RnullStr21(const algo::RnullStr21 &rhs) {
9637 operator =(rhs);
9638}
9639
9640// --- algo.RnullStr21.ch.CtorStrptr
9641inline algo::RnullStr21::RnullStr21(const algo::strptr &rhs) {
9642 ch_SetStrptr(*this, rhs);
9643}
9644
9645// --- algo.RnullStr21.ch.Cast
9646inline algo::RnullStr21::operator algo::strptr () const {
9647 return ch_Getary(*this);
9648}
9649
9650// --- algo.RnullStr21..Lt
9651inline bool algo::RnullStr21_Lt(algo::RnullStr21& lhs, algo::RnullStr21& rhs) {
9652 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
9653}
9654
9655// --- algo.RnullStr21..Cmp
9656inline i32 algo::RnullStr21_Cmp(algo::RnullStr21& lhs, algo::RnullStr21& rhs) {
9657 i32 retval = 0;
9658 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
9659 return retval;
9660}
9661
9662// --- algo.RnullStr21..Init
9663// Set all fields to initial values.
9664inline void algo::RnullStr21_Init(algo::RnullStr21& parent) {
9665 memset(parent.ch, 0, 21);
9666}
9667
9668// --- algo.RnullStr21..Eq
9669inline bool algo::RnullStr21_Eq(algo::RnullStr21& lhs, algo::RnullStr21& rhs) {
9670 bool retval = true;
9671 retval = retval
9672 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
9673 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
9674 &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16)
9675 &&*(u8*)(lhs.ch+20) == *(u8*)(rhs.ch+20);
9676 return retval;
9677}
9678
9679// --- algo.RnullStr21..Update
9680// Set value. Return true if new value is different from old value.
9681inline bool algo::RnullStr21_Update(algo::RnullStr21 &lhs, algo::RnullStr21& rhs) {
9682 bool ret = !RnullStr21_Eq(lhs, rhs); // compare values
9683 if (ret) {
9684 lhs = rhs; // update
9685 }
9686 return ret;
9687}
9688
9689// --- algo.RnullStr21..EqStrptr
9690inline bool algo::RnullStr21_EqStrptr(const algo::RnullStr21& lhs, const algo::strptr& rhs) {
9691 return algo::strptr_Eq(ch_Getary(lhs), rhs);
9692}
9693
9694inline bool algo::RnullStr24::operator ==(const algo::RnullStr24 &rhs) const {
9695 return algo::RnullStr24_Eq(const_cast<algo::RnullStr24&>(*this),const_cast<algo::RnullStr24&>(rhs));
9696}
9697
9698inline bool algo::RnullStr24::operator !=(const algo::RnullStr24 &rhs) const {
9699 return !algo::RnullStr24_Eq(const_cast<algo::RnullStr24&>(*this),const_cast<algo::RnullStr24&>(rhs));
9700}
9701
9702inline bool algo::RnullStr24::operator ==(const algo::strptr &rhs) const {
9703 return algo::RnullStr24_EqStrptr(const_cast<algo::RnullStr24&>(*this),rhs);
9704}
9705
9706inline bool algo::RnullStr24::operator <(const algo::RnullStr24 &rhs) const {
9707 return algo::RnullStr24_Lt(const_cast<algo::RnullStr24&>(*this),const_cast<algo::RnullStr24&>(rhs));
9708}
9709
9710inline bool algo::RnullStr24::operator >(const algo::RnullStr24 &rhs) const {
9711 return rhs < *this;
9712}
9713
9714inline bool algo::RnullStr24::operator <=(const algo::RnullStr24 &rhs) const {
9715 return !(rhs < *this);
9716}
9717
9718inline bool algo::RnullStr24::operator >=(const algo::RnullStr24 &rhs) const {
9719 return !(*this < rhs);
9720}
9721inline algo::RnullStr24::RnullStr24() {
9722 algo::RnullStr24_Init(*this);
9723}
9724
9725
9726// --- algo.RnullStr24.ch.Getary
9727// Access string as array of chars
9728inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr24& parent) {
9729 int len = ch_N(parent);
9730 algo::aryptr<char> ret((char*)parent.ch, len);
9731 return ret;
9732}
9733
9734// --- algo.RnullStr24.ch.HashStrptr
9735inline u32 algo::RnullStr24_Hash(u32 prev, const algo::strptr &str) {
9736 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
9737}
9738
9739// --- algo.RnullStr24.ch.Init
9740inline void algo::ch_Init(algo::RnullStr24 &parent) {
9741 memset(parent.ch, 0, 24);
9742}
9743
9744// --- algo.RnullStr24.ch.Max
9745// always return constant 24
9746inline int algo::ch_Max(algo::RnullStr24& parent) {
9747 (void)parent;
9748 return 24;
9749}
9750
9751// --- algo.RnullStr24.ch.N
9752inline int algo::ch_N(const algo::RnullStr24& parent) {
9753 u64 ret;
9754 ret = 24;
9755 while (ret>0 && parent.ch[ret-1]==u8(0)) {
9756 ret--;
9757 }
9758 return int(ret);
9759}
9760
9761// --- algo.RnullStr24.ch.AssignStrptr
9762// Copy from strptr (operator=)
9763inline void algo::RnullStr24::operator =(const algo::strptr &str) {
9764 ch_SetStrptr(*this, str);
9765}
9766
9767// --- algo.RnullStr24.ch.Set
9768// Copy from same type
9769// Copy value from RHS.
9770inline void algo::RnullStr24::operator =(const algo::RnullStr24& parent) {
9771 memcpy(ch, parent.ch, 24);
9772}
9773
9774// --- algo.RnullStr24.ch.Ctor
9775inline algo::RnullStr24::RnullStr24(const algo::RnullStr24 &rhs) {
9776 operator =(rhs);
9777}
9778
9779// --- algo.RnullStr24.ch.CtorStrptr
9780inline algo::RnullStr24::RnullStr24(const algo::strptr &rhs) {
9781 ch_SetStrptr(*this, rhs);
9782}
9783
9784// --- algo.RnullStr24.ch.Cast
9785inline algo::RnullStr24::operator algo::strptr () const {
9786 return ch_Getary(*this);
9787}
9788
9789// --- algo.RnullStr24..Lt
9790inline bool algo::RnullStr24_Lt(algo::RnullStr24& lhs, algo::RnullStr24& rhs) {
9791 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
9792}
9793
9794// --- algo.RnullStr24..Cmp
9795inline i32 algo::RnullStr24_Cmp(algo::RnullStr24& lhs, algo::RnullStr24& rhs) {
9796 i32 retval = 0;
9797 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
9798 return retval;
9799}
9800
9801// --- algo.RnullStr24..Init
9802// Set all fields to initial values.
9803inline void algo::RnullStr24_Init(algo::RnullStr24& parent) {
9804 memset(parent.ch, 0, 24);
9805}
9806
9807// --- algo.RnullStr24..Eq
9808inline bool algo::RnullStr24_Eq(algo::RnullStr24& lhs, algo::RnullStr24& rhs) {
9809 bool retval = true;
9810 retval = retval
9811 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
9812 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
9813 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16);
9814 return retval;
9815}
9816
9817// --- algo.RnullStr24..Update
9818// Set value. Return true if new value is different from old value.
9819inline bool algo::RnullStr24_Update(algo::RnullStr24 &lhs, algo::RnullStr24& rhs) {
9820 bool ret = !RnullStr24_Eq(lhs, rhs); // compare values
9821 if (ret) {
9822 lhs = rhs; // update
9823 }
9824 return ret;
9825}
9826
9827// --- algo.RnullStr24..EqStrptr
9828inline bool algo::RnullStr24_EqStrptr(const algo::RnullStr24& lhs, const algo::strptr& rhs) {
9829 return algo::strptr_Eq(ch_Getary(lhs), rhs);
9830}
9831
9832inline bool algo::RnullStr25::operator ==(const algo::RnullStr25 &rhs) const {
9833 return algo::RnullStr25_Eq(const_cast<algo::RnullStr25&>(*this),const_cast<algo::RnullStr25&>(rhs));
9834}
9835
9836inline bool algo::RnullStr25::operator !=(const algo::RnullStr25 &rhs) const {
9837 return !algo::RnullStr25_Eq(const_cast<algo::RnullStr25&>(*this),const_cast<algo::RnullStr25&>(rhs));
9838}
9839
9840inline bool algo::RnullStr25::operator ==(const algo::strptr &rhs) const {
9841 return algo::RnullStr25_EqStrptr(const_cast<algo::RnullStr25&>(*this),rhs);
9842}
9843
9844inline bool algo::RnullStr25::operator <(const algo::RnullStr25 &rhs) const {
9845 return algo::RnullStr25_Lt(const_cast<algo::RnullStr25&>(*this),const_cast<algo::RnullStr25&>(rhs));
9846}
9847
9848inline bool algo::RnullStr25::operator >(const algo::RnullStr25 &rhs) const {
9849 return rhs < *this;
9850}
9851
9852inline bool algo::RnullStr25::operator <=(const algo::RnullStr25 &rhs) const {
9853 return !(rhs < *this);
9854}
9855
9856inline bool algo::RnullStr25::operator >=(const algo::RnullStr25 &rhs) const {
9857 return !(*this < rhs);
9858}
9859inline algo::RnullStr25::RnullStr25() {
9860 algo::RnullStr25_Init(*this);
9861}
9862
9863
9864// --- algo.RnullStr25.ch.Getary
9865// Access string as array of chars
9866inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr25& parent) {
9867 int len = ch_N(parent);
9868 algo::aryptr<char> ret((char*)parent.ch, len);
9869 return ret;
9870}
9871
9872// --- algo.RnullStr25.ch.HashStrptr
9873inline u32 algo::RnullStr25_Hash(u32 prev, const algo::strptr &str) {
9874 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
9875}
9876
9877// --- algo.RnullStr25.ch.Init
9878inline void algo::ch_Init(algo::RnullStr25 &parent) {
9879 memset(parent.ch, 0, 25);
9880}
9881
9882// --- algo.RnullStr25.ch.Max
9883// always return constant 25
9884inline int algo::ch_Max(algo::RnullStr25& parent) {
9885 (void)parent;
9886 return 25;
9887}
9888
9889// --- algo.RnullStr25.ch.N
9890inline int algo::ch_N(const algo::RnullStr25& parent) {
9891 u64 ret;
9892 ret = 25;
9893 while (ret>0 && parent.ch[ret-1]==u8(0)) {
9894 ret--;
9895 }
9896 return int(ret);
9897}
9898
9899// --- algo.RnullStr25.ch.AssignStrptr
9900// Copy from strptr (operator=)
9901inline void algo::RnullStr25::operator =(const algo::strptr &str) {
9902 ch_SetStrptr(*this, str);
9903}
9904
9905// --- algo.RnullStr25.ch.Set
9906// Copy from same type
9907// Copy value from RHS.
9908inline void algo::RnullStr25::operator =(const algo::RnullStr25& parent) {
9909 memcpy(ch, parent.ch, 25);
9910}
9911
9912// --- algo.RnullStr25.ch.Ctor
9913inline algo::RnullStr25::RnullStr25(const algo::RnullStr25 &rhs) {
9914 operator =(rhs);
9915}
9916
9917// --- algo.RnullStr25.ch.CtorStrptr
9918inline algo::RnullStr25::RnullStr25(const algo::strptr &rhs) {
9919 ch_SetStrptr(*this, rhs);
9920}
9921
9922// --- algo.RnullStr25.ch.Cast
9923inline algo::RnullStr25::operator algo::strptr () const {
9924 return ch_Getary(*this);
9925}
9926
9927// --- algo.RnullStr25..Lt
9928inline bool algo::RnullStr25_Lt(algo::RnullStr25& lhs, algo::RnullStr25& rhs) {
9929 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
9930}
9931
9932// --- algo.RnullStr25..Cmp
9933inline i32 algo::RnullStr25_Cmp(algo::RnullStr25& lhs, algo::RnullStr25& rhs) {
9934 i32 retval = 0;
9935 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
9936 return retval;
9937}
9938
9939// --- algo.RnullStr25..Init
9940// Set all fields to initial values.
9941inline void algo::RnullStr25_Init(algo::RnullStr25& parent) {
9942 memset(parent.ch, 0, 25);
9943}
9944
9945// --- algo.RnullStr25..Eq
9946inline bool algo::RnullStr25_Eq(algo::RnullStr25& lhs, algo::RnullStr25& rhs) {
9947 bool retval = true;
9948 retval = retval
9949 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
9950 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
9951 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
9952 &&*(u8*)(lhs.ch+24) == *(u8*)(rhs.ch+24);
9953 return retval;
9954}
9955
9956// --- algo.RnullStr25..Update
9957// Set value. Return true if new value is different from old value.
9958inline bool algo::RnullStr25_Update(algo::RnullStr25 &lhs, algo::RnullStr25& rhs) {
9959 bool ret = !RnullStr25_Eq(lhs, rhs); // compare values
9960 if (ret) {
9961 lhs = rhs; // update
9962 }
9963 return ret;
9964}
9965
9966// --- algo.RnullStr25..EqStrptr
9967inline bool algo::RnullStr25_EqStrptr(const algo::RnullStr25& lhs, const algo::strptr& rhs) {
9968 return algo::strptr_Eq(ch_Getary(lhs), rhs);
9969}
9970
9971inline bool algo::RnullStr28::operator ==(const algo::RnullStr28 &rhs) const {
9972 return algo::RnullStr28_Eq(const_cast<algo::RnullStr28&>(*this),const_cast<algo::RnullStr28&>(rhs));
9973}
9974
9975inline bool algo::RnullStr28::operator !=(const algo::RnullStr28 &rhs) const {
9976 return !algo::RnullStr28_Eq(const_cast<algo::RnullStr28&>(*this),const_cast<algo::RnullStr28&>(rhs));
9977}
9978
9979inline bool algo::RnullStr28::operator ==(const algo::strptr &rhs) const {
9980 return algo::RnullStr28_EqStrptr(const_cast<algo::RnullStr28&>(*this),rhs);
9981}
9982
9983inline bool algo::RnullStr28::operator <(const algo::RnullStr28 &rhs) const {
9984 return algo::RnullStr28_Lt(const_cast<algo::RnullStr28&>(*this),const_cast<algo::RnullStr28&>(rhs));
9985}
9986
9987inline bool algo::RnullStr28::operator >(const algo::RnullStr28 &rhs) const {
9988 return rhs < *this;
9989}
9990
9991inline bool algo::RnullStr28::operator <=(const algo::RnullStr28 &rhs) const {
9992 return !(rhs < *this);
9993}
9994
9995inline bool algo::RnullStr28::operator >=(const algo::RnullStr28 &rhs) const {
9996 return !(*this < rhs);
9997}
9998inline algo::RnullStr28::RnullStr28() {
9999 algo::RnullStr28_Init(*this);
10000}
10001
10002
10003// --- algo.RnullStr28.ch.Getary
10004// Access string as array of chars
10005inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr28& parent) {
10006 int len = ch_N(parent);
10007 algo::aryptr<char> ret((char*)parent.ch, len);
10008 return ret;
10009}
10010
10011// --- algo.RnullStr28.ch.HashStrptr
10012inline u32 algo::RnullStr28_Hash(u32 prev, const algo::strptr &str) {
10013 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10014}
10015
10016// --- algo.RnullStr28.ch.Init
10017inline void algo::ch_Init(algo::RnullStr28 &parent) {
10018 memset(parent.ch, 0, 28);
10019}
10020
10021// --- algo.RnullStr28.ch.Max
10022// always return constant 28
10023inline int algo::ch_Max(algo::RnullStr28& parent) {
10024 (void)parent;
10025 return 28;
10026}
10027
10028// --- algo.RnullStr28.ch.N
10029inline int algo::ch_N(const algo::RnullStr28& parent) {
10030 u64 ret;
10031 ret = 28;
10032 while (ret>0 && parent.ch[ret-1]==u8(0)) {
10033 ret--;
10034 }
10035 return int(ret);
10036}
10037
10038// --- algo.RnullStr28.ch.AssignStrptr
10039// Copy from strptr (operator=)
10040inline void algo::RnullStr28::operator =(const algo::strptr &str) {
10041 ch_SetStrptr(*this, str);
10042}
10043
10044// --- algo.RnullStr28.ch.Set
10045// Copy from same type
10046// Copy value from RHS.
10047inline void algo::RnullStr28::operator =(const algo::RnullStr28& parent) {
10048 memcpy(ch, parent.ch, 28);
10049}
10050
10051// --- algo.RnullStr28.ch.Ctor
10052inline algo::RnullStr28::RnullStr28(const algo::RnullStr28 &rhs) {
10053 operator =(rhs);
10054}
10055
10056// --- algo.RnullStr28.ch.CtorStrptr
10057inline algo::RnullStr28::RnullStr28(const algo::strptr &rhs) {
10058 ch_SetStrptr(*this, rhs);
10059}
10060
10061// --- algo.RnullStr28.ch.Cast
10062inline algo::RnullStr28::operator algo::strptr () const {
10063 return ch_Getary(*this);
10064}
10065
10066// --- algo.RnullStr28..Lt
10067inline bool algo::RnullStr28_Lt(algo::RnullStr28& lhs, algo::RnullStr28& rhs) {
10068 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10069}
10070
10071// --- algo.RnullStr28..Cmp
10072inline i32 algo::RnullStr28_Cmp(algo::RnullStr28& lhs, algo::RnullStr28& rhs) {
10073 i32 retval = 0;
10074 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10075 return retval;
10076}
10077
10078// --- algo.RnullStr28..Init
10079// Set all fields to initial values.
10080inline void algo::RnullStr28_Init(algo::RnullStr28& parent) {
10081 memset(parent.ch, 0, 28);
10082}
10083
10084// --- algo.RnullStr28..Eq
10085inline bool algo::RnullStr28_Eq(algo::RnullStr28& lhs, algo::RnullStr28& rhs) {
10086 bool retval = true;
10087 retval = retval
10088 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10089 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10090 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10091 &&*(u32*)(lhs.ch+24) == *(u32*)(rhs.ch+24);
10092 return retval;
10093}
10094
10095// --- algo.RnullStr28..Update
10096// Set value. Return true if new value is different from old value.
10097inline bool algo::RnullStr28_Update(algo::RnullStr28 &lhs, algo::RnullStr28& rhs) {
10098 bool ret = !RnullStr28_Eq(lhs, rhs); // compare values
10099 if (ret) {
10100 lhs = rhs; // update
10101 }
10102 return ret;
10103}
10104
10105// --- algo.RnullStr28..EqStrptr
10106inline bool algo::RnullStr28_EqStrptr(const algo::RnullStr28& lhs, const algo::strptr& rhs) {
10107 return algo::strptr_Eq(ch_Getary(lhs), rhs);
10108}
10109
10110inline bool algo::RnullStr3::operator ==(const algo::RnullStr3 &rhs) const {
10111 return algo::RnullStr3_Eq(const_cast<algo::RnullStr3&>(*this),const_cast<algo::RnullStr3&>(rhs));
10112}
10113
10114inline bool algo::RnullStr3::operator !=(const algo::RnullStr3 &rhs) const {
10115 return !algo::RnullStr3_Eq(const_cast<algo::RnullStr3&>(*this),const_cast<algo::RnullStr3&>(rhs));
10116}
10117
10118inline bool algo::RnullStr3::operator ==(const algo::strptr &rhs) const {
10119 return algo::RnullStr3_EqStrptr(const_cast<algo::RnullStr3&>(*this),rhs);
10120}
10121
10122inline bool algo::RnullStr3::operator <(const algo::RnullStr3 &rhs) const {
10123 return algo::RnullStr3_Lt(const_cast<algo::RnullStr3&>(*this),const_cast<algo::RnullStr3&>(rhs));
10124}
10125
10126inline bool algo::RnullStr3::operator >(const algo::RnullStr3 &rhs) const {
10127 return rhs < *this;
10128}
10129
10130inline bool algo::RnullStr3::operator <=(const algo::RnullStr3 &rhs) const {
10131 return !(rhs < *this);
10132}
10133
10134inline bool algo::RnullStr3::operator >=(const algo::RnullStr3 &rhs) const {
10135 return !(*this < rhs);
10136}
10137inline algo::RnullStr3::RnullStr3() {
10138 algo::RnullStr3_Init(*this);
10139}
10140
10141
10142// --- algo.RnullStr3.ch.Getary
10143// Access string as array of chars
10144inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr3& parent) {
10145 int len = ch_N(parent);
10146 algo::aryptr<char> ret((char*)parent.ch, len);
10147 return ret;
10148}
10149
10150// --- algo.RnullStr3.ch.HashStrptr
10151inline u32 algo::RnullStr3_Hash(u32 prev, const algo::strptr &str) {
10152 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10153}
10154
10155// --- algo.RnullStr3.ch.Init
10156inline void algo::ch_Init(algo::RnullStr3 &parent) {
10157 memset(parent.ch, 0, 3);
10158}
10159
10160// --- algo.RnullStr3.ch.Max
10161// always return constant 3
10162inline int algo::ch_Max(algo::RnullStr3& parent) {
10163 (void)parent;
10164 return 3;
10165}
10166
10167// --- algo.RnullStr3.ch.N
10168inline int algo::ch_N(const algo::RnullStr3& parent) {
10169 u64 ret;
10170 ret = 3;
10171 while (ret>0 && parent.ch[ret-1]==u8(0)) {
10172 ret--;
10173 }
10174 return int(ret);
10175}
10176
10177// --- algo.RnullStr3.ch.AssignStrptr
10178// Copy from strptr (operator=)
10179inline void algo::RnullStr3::operator =(const algo::strptr &str) {
10180 ch_SetStrptr(*this, str);
10181}
10182
10183// --- algo.RnullStr3.ch.Set
10184// Copy from same type
10185// Copy value from RHS.
10186inline void algo::RnullStr3::operator =(const algo::RnullStr3& parent) {
10187 memcpy(ch, parent.ch, 3);
10188}
10189
10190// --- algo.RnullStr3.ch.Ctor
10191inline algo::RnullStr3::RnullStr3(const algo::RnullStr3 &rhs) {
10192 operator =(rhs);
10193}
10194
10195// --- algo.RnullStr3.ch.CtorStrptr
10196inline algo::RnullStr3::RnullStr3(const algo::strptr &rhs) {
10197 ch_SetStrptr(*this, rhs);
10198}
10199
10200// --- algo.RnullStr3.ch.Cast
10201inline algo::RnullStr3::operator algo::strptr () const {
10202 return ch_Getary(*this);
10203}
10204
10205// --- algo.RnullStr3..Lt
10206inline bool algo::RnullStr3_Lt(algo::RnullStr3 lhs, algo::RnullStr3 rhs) {
10207 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10208}
10209
10210// --- algo.RnullStr3..Cmp
10211inline i32 algo::RnullStr3_Cmp(algo::RnullStr3 lhs, algo::RnullStr3 rhs) {
10212 i32 retval = 0;
10213 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10214 return retval;
10215}
10216
10217// --- algo.RnullStr3..Init
10218// Set all fields to initial values.
10219inline void algo::RnullStr3_Init(algo::RnullStr3& parent) {
10220 memset(parent.ch, 0, 3);
10221}
10222
10223// --- algo.RnullStr3..Eq
10224inline bool algo::RnullStr3_Eq(algo::RnullStr3 lhs, algo::RnullStr3 rhs) {
10225 bool retval = true;
10226 retval = retval
10227 &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
10228 &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
10229 return retval;
10230}
10231
10232// --- algo.RnullStr3..Update
10233// Set value. Return true if new value is different from old value.
10234inline bool algo::RnullStr3_Update(algo::RnullStr3 &lhs, algo::RnullStr3 rhs) {
10235 bool ret = !RnullStr3_Eq(lhs, rhs); // compare values
10236 if (ret) {
10237 lhs = rhs; // update
10238 }
10239 return ret;
10240}
10241
10242// --- algo.RnullStr3..EqStrptr
10243inline bool algo::RnullStr3_EqStrptr(algo::RnullStr3 lhs, const algo::strptr& rhs) {
10244 return algo::strptr_Eq(ch_Getary(lhs), rhs);
10245}
10246inline algo::RnullStr30::RnullStr30() {
10247 algo::RnullStr30_Init(*this);
10248}
10249
10250
10251// --- algo.RnullStr30.ch.Getary
10252// Access string as array of chars
10253inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr30& parent) {
10254 int len = ch_N(parent);
10255 algo::aryptr<char> ret((char*)parent.ch, len);
10256 return ret;
10257}
10258
10259// --- algo.RnullStr30.ch.HashStrptr
10260inline u32 algo::RnullStr30_Hash(u32 prev, const algo::strptr &str) {
10261 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10262}
10263
10264// --- algo.RnullStr30.ch.Init
10265inline void algo::ch_Init(algo::RnullStr30 &parent) {
10266 memset(parent.ch, 0, 30);
10267}
10268
10269// --- algo.RnullStr30.ch.Max
10270// always return constant 30
10271inline int algo::ch_Max(algo::RnullStr30& parent) {
10272 (void)parent;
10273 return 30;
10274}
10275
10276// --- algo.RnullStr30.ch.N
10277inline int algo::ch_N(const algo::RnullStr30& parent) {
10278 u64 ret;
10279 ret = 30;
10280 while (ret>0 && parent.ch[ret-1]==u8(0)) {
10281 ret--;
10282 }
10283 return int(ret);
10284}
10285
10286// --- algo.RnullStr30.ch.AssignStrptr
10287// Copy from strptr (operator=)
10288inline void algo::RnullStr30::operator =(const algo::strptr &str) {
10289 ch_SetStrptr(*this, str);
10290}
10291
10292// --- algo.RnullStr30.ch.Set
10293// Copy from same type
10294// Copy value from RHS.
10295inline void algo::RnullStr30::operator =(const algo::RnullStr30& parent) {
10296 memcpy(ch, parent.ch, 30);
10297}
10298
10299// --- algo.RnullStr30.ch.Ctor
10300inline algo::RnullStr30::RnullStr30(const algo::RnullStr30 &rhs) {
10301 operator =(rhs);
10302}
10303
10304// --- algo.RnullStr30.ch.CtorStrptr
10305inline algo::RnullStr30::RnullStr30(const algo::strptr &rhs) {
10306 ch_SetStrptr(*this, rhs);
10307}
10308
10309// --- algo.RnullStr30.ch.Cast
10310inline algo::RnullStr30::operator algo::strptr () const {
10311 return ch_Getary(*this);
10312}
10313
10314// --- algo.RnullStr30..Lt
10315inline bool algo::RnullStr30_Lt(algo::RnullStr30 lhs, algo::RnullStr30 rhs) {
10316 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10317}
10318
10319// --- algo.RnullStr30..Cmp
10320inline i32 algo::RnullStr30_Cmp(algo::RnullStr30 lhs, algo::RnullStr30 rhs) {
10321 i32 retval = 0;
10322 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10323 return retval;
10324}
10325
10326// --- algo.RnullStr30..Init
10327// Set all fields to initial values.
10328inline void algo::RnullStr30_Init(algo::RnullStr30& parent) {
10329 memset(parent.ch, 0, 30);
10330}
10331
10332// --- algo.RnullStr30..Eq
10333inline bool algo::RnullStr30_Eq(algo::RnullStr30 lhs, algo::RnullStr30 rhs) {
10334 bool retval = true;
10335 retval = retval
10336 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10337 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10338 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10339 &&*(u32*)(lhs.ch+24) == *(u32*)(rhs.ch+24)
10340 &&*(u16*)(lhs.ch+28) == *(u16*)(rhs.ch+28);
10341 return retval;
10342}
10343
10344// --- algo.RnullStr30..Update
10345// Set value. Return true if new value is different from old value.
10346inline bool algo::RnullStr30_Update(algo::RnullStr30 &lhs, algo::RnullStr30 rhs) {
10347 bool ret = !RnullStr30_Eq(lhs, rhs); // compare values
10348 if (ret) {
10349 lhs = rhs; // update
10350 }
10351 return ret;
10352}
10353
10354// --- algo.RnullStr30..EqStrptr
10355inline bool algo::RnullStr30_EqStrptr(algo::RnullStr30 lhs, const algo::strptr& rhs) {
10356 return algo::strptr_Eq(ch_Getary(lhs), rhs);
10357}
10358
10359inline bool algo::RnullStr32::operator ==(const algo::RnullStr32 &rhs) const {
10360 return algo::RnullStr32_Eq(const_cast<algo::RnullStr32&>(*this),const_cast<algo::RnullStr32&>(rhs));
10361}
10362
10363inline bool algo::RnullStr32::operator !=(const algo::RnullStr32 &rhs) const {
10364 return !algo::RnullStr32_Eq(const_cast<algo::RnullStr32&>(*this),const_cast<algo::RnullStr32&>(rhs));
10365}
10366
10367inline bool algo::RnullStr32::operator ==(const algo::strptr &rhs) const {
10368 return algo::RnullStr32_EqStrptr(const_cast<algo::RnullStr32&>(*this),rhs);
10369}
10370
10371inline bool algo::RnullStr32::operator <(const algo::RnullStr32 &rhs) const {
10372 return algo::RnullStr32_Lt(const_cast<algo::RnullStr32&>(*this),const_cast<algo::RnullStr32&>(rhs));
10373}
10374
10375inline bool algo::RnullStr32::operator >(const algo::RnullStr32 &rhs) const {
10376 return rhs < *this;
10377}
10378
10379inline bool algo::RnullStr32::operator <=(const algo::RnullStr32 &rhs) const {
10380 return !(rhs < *this);
10381}
10382
10383inline bool algo::RnullStr32::operator >=(const algo::RnullStr32 &rhs) const {
10384 return !(*this < rhs);
10385}
10386inline algo::RnullStr32::RnullStr32() {
10387 algo::RnullStr32_Init(*this);
10388}
10389
10390
10391// --- algo.RnullStr32.ch.Getary
10392// Access string as array of chars
10393inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr32& parent) {
10394 int len = ch_N(parent);
10395 algo::aryptr<char> ret((char*)parent.ch, len);
10396 return ret;
10397}
10398
10399// --- algo.RnullStr32.ch.HashStrptr
10400inline u32 algo::RnullStr32_Hash(u32 prev, const algo::strptr &str) {
10401 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10402}
10403
10404// --- algo.RnullStr32.ch.Init
10405inline void algo::ch_Init(algo::RnullStr32 &parent) {
10406 memset(parent.ch, 0, 32);
10407}
10408
10409// --- algo.RnullStr32.ch.Max
10410// always return constant 32
10411inline int algo::ch_Max(algo::RnullStr32& parent) {
10412 (void)parent;
10413 return 32;
10414}
10415
10416// --- algo.RnullStr32.ch.N
10417inline int algo::ch_N(const algo::RnullStr32& parent) {
10418 u64 ret;
10419 ret = 32;
10420 while (ret>0 && parent.ch[ret-1]==u8(0)) {
10421 ret--;
10422 }
10423 return int(ret);
10424}
10425
10426// --- algo.RnullStr32.ch.AssignStrptr
10427// Copy from strptr (operator=)
10428inline void algo::RnullStr32::operator =(const algo::strptr &str) {
10429 ch_SetStrptr(*this, str);
10430}
10431
10432// --- algo.RnullStr32.ch.Set
10433// Copy from same type
10434// Copy value from RHS.
10435inline void algo::RnullStr32::operator =(const algo::RnullStr32& parent) {
10436 memcpy(ch, parent.ch, 32);
10437}
10438
10439// --- algo.RnullStr32.ch.Ctor
10440inline algo::RnullStr32::RnullStr32(const algo::RnullStr32 &rhs) {
10441 operator =(rhs);
10442}
10443
10444// --- algo.RnullStr32.ch.CtorStrptr
10445inline algo::RnullStr32::RnullStr32(const algo::strptr &rhs) {
10446 ch_SetStrptr(*this, rhs);
10447}
10448
10449// --- algo.RnullStr32.ch.Cast
10450inline algo::RnullStr32::operator algo::strptr () const {
10451 return ch_Getary(*this);
10452}
10453
10454// --- algo.RnullStr32..Lt
10455inline bool algo::RnullStr32_Lt(algo::RnullStr32 lhs, algo::RnullStr32 rhs) {
10456 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10457}
10458
10459// --- algo.RnullStr32..Cmp
10460inline i32 algo::RnullStr32_Cmp(algo::RnullStr32 lhs, algo::RnullStr32 rhs) {
10461 i32 retval = 0;
10462 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10463 return retval;
10464}
10465
10466// --- algo.RnullStr32..Init
10467// Set all fields to initial values.
10468inline void algo::RnullStr32_Init(algo::RnullStr32& parent) {
10469 memset(parent.ch, 0, 32);
10470}
10471
10472// --- algo.RnullStr32..Eq
10473inline bool algo::RnullStr32_Eq(algo::RnullStr32 lhs, algo::RnullStr32 rhs) {
10474 bool retval = true;
10475 retval = retval
10476 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10477 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10478 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10479 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24);
10480 return retval;
10481}
10482
10483// --- algo.RnullStr32..Update
10484// Set value. Return true if new value is different from old value.
10485inline bool algo::RnullStr32_Update(algo::RnullStr32 &lhs, algo::RnullStr32 rhs) {
10486 bool ret = !RnullStr32_Eq(lhs, rhs); // compare values
10487 if (ret) {
10488 lhs = rhs; // update
10489 }
10490 return ret;
10491}
10492
10493// --- algo.RnullStr32..EqStrptr
10494inline bool algo::RnullStr32_EqStrptr(algo::RnullStr32 lhs, const algo::strptr& rhs) {
10495 return algo::strptr_Eq(ch_Getary(lhs), rhs);
10496}
10497
10498inline bool algo::RnullStr33::operator ==(const algo::RnullStr33 &rhs) const {
10499 return algo::RnullStr33_Eq(const_cast<algo::RnullStr33&>(*this),const_cast<algo::RnullStr33&>(rhs));
10500}
10501
10502inline bool algo::RnullStr33::operator !=(const algo::RnullStr33 &rhs) const {
10503 return !algo::RnullStr33_Eq(const_cast<algo::RnullStr33&>(*this),const_cast<algo::RnullStr33&>(rhs));
10504}
10505
10506inline bool algo::RnullStr33::operator ==(const algo::strptr &rhs) const {
10507 return algo::RnullStr33_EqStrptr(const_cast<algo::RnullStr33&>(*this),rhs);
10508}
10509
10510inline bool algo::RnullStr33::operator <(const algo::RnullStr33 &rhs) const {
10511 return algo::RnullStr33_Lt(const_cast<algo::RnullStr33&>(*this),const_cast<algo::RnullStr33&>(rhs));
10512}
10513
10514inline bool algo::RnullStr33::operator >(const algo::RnullStr33 &rhs) const {
10515 return rhs < *this;
10516}
10517
10518inline bool algo::RnullStr33::operator <=(const algo::RnullStr33 &rhs) const {
10519 return !(rhs < *this);
10520}
10521
10522inline bool algo::RnullStr33::operator >=(const algo::RnullStr33 &rhs) const {
10523 return !(*this < rhs);
10524}
10525inline algo::RnullStr33::RnullStr33() {
10526 algo::RnullStr33_Init(*this);
10527}
10528
10529
10530// --- algo.RnullStr33.ch.Getary
10531// Access string as array of chars
10532inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr33& parent) {
10533 int len = ch_N(parent);
10534 algo::aryptr<char> ret((char*)parent.ch, len);
10535 return ret;
10536}
10537
10538// --- algo.RnullStr33.ch.HashStrptr
10539inline u32 algo::RnullStr33_Hash(u32 prev, const algo::strptr &str) {
10540 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10541}
10542
10543// --- algo.RnullStr33.ch.Init
10544inline void algo::ch_Init(algo::RnullStr33 &parent) {
10545 memset(parent.ch, 0, 33);
10546}
10547
10548// --- algo.RnullStr33.ch.Max
10549// always return constant 33
10550inline int algo::ch_Max(algo::RnullStr33& parent) {
10551 (void)parent;
10552 return 33;
10553}
10554
10555// --- algo.RnullStr33.ch.N
10556inline int algo::ch_N(const algo::RnullStr33& parent) {
10557 u64 ret;
10558 ret = 33;
10559 while (ret>0 && parent.ch[ret-1]==u8(0)) {
10560 ret--;
10561 }
10562 return int(ret);
10563}
10564
10565// --- algo.RnullStr33.ch.AssignStrptr
10566// Copy from strptr (operator=)
10567inline void algo::RnullStr33::operator =(const algo::strptr &str) {
10568 ch_SetStrptr(*this, str);
10569}
10570
10571// --- algo.RnullStr33.ch.Set
10572// Copy from same type
10573// Copy value from RHS.
10574inline void algo::RnullStr33::operator =(const algo::RnullStr33& parent) {
10575 memcpy(ch, parent.ch, 33);
10576}
10577
10578// --- algo.RnullStr33.ch.Ctor
10579inline algo::RnullStr33::RnullStr33(const algo::RnullStr33 &rhs) {
10580 operator =(rhs);
10581}
10582
10583// --- algo.RnullStr33.ch.CtorStrptr
10584inline algo::RnullStr33::RnullStr33(const algo::strptr &rhs) {
10585 ch_SetStrptr(*this, rhs);
10586}
10587
10588// --- algo.RnullStr33.ch.Cast
10589inline algo::RnullStr33::operator algo::strptr () const {
10590 return ch_Getary(*this);
10591}
10592
10593// --- algo.RnullStr33..Lt
10594inline bool algo::RnullStr33_Lt(algo::RnullStr33& lhs, algo::RnullStr33& rhs) {
10595 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10596}
10597
10598// --- algo.RnullStr33..Cmp
10599inline i32 algo::RnullStr33_Cmp(algo::RnullStr33& lhs, algo::RnullStr33& rhs) {
10600 i32 retval = 0;
10601 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10602 return retval;
10603}
10604
10605// --- algo.RnullStr33..Init
10606// Set all fields to initial values.
10607inline void algo::RnullStr33_Init(algo::RnullStr33& parent) {
10608 memset(parent.ch, 0, 33);
10609}
10610
10611// --- algo.RnullStr33..Eq
10612inline bool algo::RnullStr33_Eq(algo::RnullStr33& lhs, algo::RnullStr33& rhs) {
10613 bool retval = true;
10614 retval = retval
10615 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10616 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10617 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10618 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
10619 &&*(u8*)(lhs.ch+32) == *(u8*)(rhs.ch+32);
10620 return retval;
10621}
10622
10623// --- algo.RnullStr33..Update
10624// Set value. Return true if new value is different from old value.
10625inline bool algo::RnullStr33_Update(algo::RnullStr33 &lhs, algo::RnullStr33& rhs) {
10626 bool ret = !RnullStr33_Eq(lhs, rhs); // compare values
10627 if (ret) {
10628 lhs = rhs; // update
10629 }
10630 return ret;
10631}
10632
10633// --- algo.RnullStr33..EqStrptr
10634inline bool algo::RnullStr33_EqStrptr(const algo::RnullStr33& lhs, const algo::strptr& rhs) {
10635 return algo::strptr_Eq(ch_Getary(lhs), rhs);
10636}
10637
10638inline bool algo::RnullStr35::operator ==(const algo::RnullStr35 &rhs) const {
10639 return algo::RnullStr35_Eq(const_cast<algo::RnullStr35&>(*this),const_cast<algo::RnullStr35&>(rhs));
10640}
10641
10642inline bool algo::RnullStr35::operator !=(const algo::RnullStr35 &rhs) const {
10643 return !algo::RnullStr35_Eq(const_cast<algo::RnullStr35&>(*this),const_cast<algo::RnullStr35&>(rhs));
10644}
10645
10646inline bool algo::RnullStr35::operator ==(const algo::strptr &rhs) const {
10647 return algo::RnullStr35_EqStrptr(const_cast<algo::RnullStr35&>(*this),rhs);
10648}
10649
10650inline bool algo::RnullStr35::operator <(const algo::RnullStr35 &rhs) const {
10651 return algo::RnullStr35_Lt(const_cast<algo::RnullStr35&>(*this),const_cast<algo::RnullStr35&>(rhs));
10652}
10653
10654inline bool algo::RnullStr35::operator >(const algo::RnullStr35 &rhs) const {
10655 return rhs < *this;
10656}
10657
10658inline bool algo::RnullStr35::operator <=(const algo::RnullStr35 &rhs) const {
10659 return !(rhs < *this);
10660}
10661
10662inline bool algo::RnullStr35::operator >=(const algo::RnullStr35 &rhs) const {
10663 return !(*this < rhs);
10664}
10665inline algo::RnullStr35::RnullStr35() {
10666 algo::RnullStr35_Init(*this);
10667}
10668
10669
10670// --- algo.RnullStr35.ch.Getary
10671// Access string as array of chars
10672inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr35& parent) {
10673 int len = ch_N(parent);
10674 algo::aryptr<char> ret((char*)parent.ch, len);
10675 return ret;
10676}
10677
10678// --- algo.RnullStr35.ch.HashStrptr
10679inline u32 algo::RnullStr35_Hash(u32 prev, const algo::strptr &str) {
10680 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10681}
10682
10683// --- algo.RnullStr35.ch.Init
10684inline void algo::ch_Init(algo::RnullStr35 &parent) {
10685 memset(parent.ch, 0, 35);
10686}
10687
10688// --- algo.RnullStr35.ch.Max
10689// always return constant 35
10690inline int algo::ch_Max(algo::RnullStr35& parent) {
10691 (void)parent;
10692 return 35;
10693}
10694
10695// --- algo.RnullStr35.ch.N
10696inline int algo::ch_N(const algo::RnullStr35& parent) {
10697 u64 ret;
10698 ret = 35;
10699 while (ret>0 && parent.ch[ret-1]==u8(0)) {
10700 ret--;
10701 }
10702 return int(ret);
10703}
10704
10705// --- algo.RnullStr35.ch.AssignStrptr
10706// Copy from strptr (operator=)
10707inline void algo::RnullStr35::operator =(const algo::strptr &str) {
10708 ch_SetStrptr(*this, str);
10709}
10710
10711// --- algo.RnullStr35.ch.Set
10712// Copy from same type
10713// Copy value from RHS.
10714inline void algo::RnullStr35::operator =(const algo::RnullStr35& parent) {
10715 memcpy(ch, parent.ch, 35);
10716}
10717
10718// --- algo.RnullStr35.ch.Ctor
10719inline algo::RnullStr35::RnullStr35(const algo::RnullStr35 &rhs) {
10720 operator =(rhs);
10721}
10722
10723// --- algo.RnullStr35.ch.CtorStrptr
10724inline algo::RnullStr35::RnullStr35(const algo::strptr &rhs) {
10725 ch_SetStrptr(*this, rhs);
10726}
10727
10728// --- algo.RnullStr35.ch.Cast
10729inline algo::RnullStr35::operator algo::strptr () const {
10730 return ch_Getary(*this);
10731}
10732
10733// --- algo.RnullStr35..Lt
10734inline bool algo::RnullStr35_Lt(algo::RnullStr35& lhs, algo::RnullStr35& rhs) {
10735 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10736}
10737
10738// --- algo.RnullStr35..Cmp
10739inline i32 algo::RnullStr35_Cmp(algo::RnullStr35& lhs, algo::RnullStr35& rhs) {
10740 i32 retval = 0;
10741 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10742 return retval;
10743}
10744
10745// --- algo.RnullStr35..Init
10746// Set all fields to initial values.
10747inline void algo::RnullStr35_Init(algo::RnullStr35& parent) {
10748 memset(parent.ch, 0, 35);
10749}
10750
10751// --- algo.RnullStr35..Eq
10752inline bool algo::RnullStr35_Eq(algo::RnullStr35& lhs, algo::RnullStr35& rhs) {
10753 bool retval = true;
10754 retval = retval
10755 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10756 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10757 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10758 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
10759 &&*(u16*)(lhs.ch+32) == *(u16*)(rhs.ch+32)
10760 &&*(u8*)(lhs.ch+34) == *(u8*)(rhs.ch+34);
10761 return retval;
10762}
10763
10764// --- algo.RnullStr35..Update
10765// Set value. Return true if new value is different from old value.
10766inline bool algo::RnullStr35_Update(algo::RnullStr35 &lhs, algo::RnullStr35& rhs) {
10767 bool ret = !RnullStr35_Eq(lhs, rhs); // compare values
10768 if (ret) {
10769 lhs = rhs; // update
10770 }
10771 return ret;
10772}
10773
10774// --- algo.RnullStr35..EqStrptr
10775inline bool algo::RnullStr35_EqStrptr(const algo::RnullStr35& lhs, const algo::strptr& rhs) {
10776 return algo::strptr_Eq(ch_Getary(lhs), rhs);
10777}
10778
10779inline bool algo::RnullStr36::operator ==(const algo::RnullStr36 &rhs) const {
10780 return algo::RnullStr36_Eq(const_cast<algo::RnullStr36&>(*this),const_cast<algo::RnullStr36&>(rhs));
10781}
10782
10783inline bool algo::RnullStr36::operator !=(const algo::RnullStr36 &rhs) const {
10784 return !algo::RnullStr36_Eq(const_cast<algo::RnullStr36&>(*this),const_cast<algo::RnullStr36&>(rhs));
10785}
10786
10787inline bool algo::RnullStr36::operator ==(const algo::strptr &rhs) const {
10788 return algo::RnullStr36_EqStrptr(const_cast<algo::RnullStr36&>(*this),rhs);
10789}
10790
10791inline bool algo::RnullStr36::operator <(const algo::RnullStr36 &rhs) const {
10792 return algo::RnullStr36_Lt(const_cast<algo::RnullStr36&>(*this),const_cast<algo::RnullStr36&>(rhs));
10793}
10794
10795inline bool algo::RnullStr36::operator >(const algo::RnullStr36 &rhs) const {
10796 return rhs < *this;
10797}
10798
10799inline bool algo::RnullStr36::operator <=(const algo::RnullStr36 &rhs) const {
10800 return !(rhs < *this);
10801}
10802
10803inline bool algo::RnullStr36::operator >=(const algo::RnullStr36 &rhs) const {
10804 return !(*this < rhs);
10805}
10806inline algo::RnullStr36::RnullStr36() {
10807 algo::RnullStr36_Init(*this);
10808}
10809
10810
10811// --- algo.RnullStr36.ch.Getary
10812// Access string as array of chars
10813inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr36& parent) {
10814 int len = ch_N(parent);
10815 algo::aryptr<char> ret((char*)parent.ch, len);
10816 return ret;
10817}
10818
10819// --- algo.RnullStr36.ch.HashStrptr
10820inline u32 algo::RnullStr36_Hash(u32 prev, const algo::strptr &str) {
10821 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10822}
10823
10824// --- algo.RnullStr36.ch.Init
10825inline void algo::ch_Init(algo::RnullStr36 &parent) {
10826 memset(parent.ch, 0, 36);
10827}
10828
10829// --- algo.RnullStr36.ch.Max
10830// always return constant 36
10831inline int algo::ch_Max(algo::RnullStr36& parent) {
10832 (void)parent;
10833 return 36;
10834}
10835
10836// --- algo.RnullStr36.ch.N
10837inline int algo::ch_N(const algo::RnullStr36& parent) {
10838 u64 ret;
10839 ret = 36;
10840 while (ret>0 && parent.ch[ret-1]==u8(0)) {
10841 ret--;
10842 }
10843 return int(ret);
10844}
10845
10846// --- algo.RnullStr36.ch.AssignStrptr
10847// Copy from strptr (operator=)
10848inline void algo::RnullStr36::operator =(const algo::strptr &str) {
10849 ch_SetStrptr(*this, str);
10850}
10851
10852// --- algo.RnullStr36.ch.Set
10853// Copy from same type
10854// Copy value from RHS.
10855inline void algo::RnullStr36::operator =(const algo::RnullStr36& parent) {
10856 memcpy(ch, parent.ch, 36);
10857}
10858
10859// --- algo.RnullStr36.ch.Ctor
10860inline algo::RnullStr36::RnullStr36(const algo::RnullStr36 &rhs) {
10861 operator =(rhs);
10862}
10863
10864// --- algo.RnullStr36.ch.CtorStrptr
10865inline algo::RnullStr36::RnullStr36(const algo::strptr &rhs) {
10866 ch_SetStrptr(*this, rhs);
10867}
10868
10869// --- algo.RnullStr36.ch.Cast
10870inline algo::RnullStr36::operator algo::strptr () const {
10871 return ch_Getary(*this);
10872}
10873
10874// --- algo.RnullStr36..Lt
10875inline bool algo::RnullStr36_Lt(algo::RnullStr36& lhs, algo::RnullStr36& rhs) {
10876 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10877}
10878
10879// --- algo.RnullStr36..Cmp
10880inline i32 algo::RnullStr36_Cmp(algo::RnullStr36& lhs, algo::RnullStr36& rhs) {
10881 i32 retval = 0;
10882 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10883 return retval;
10884}
10885
10886// --- algo.RnullStr36..Init
10887// Set all fields to initial values.
10888inline void algo::RnullStr36_Init(algo::RnullStr36& parent) {
10889 memset(parent.ch, 0, 36);
10890}
10891
10892// --- algo.RnullStr36..Eq
10893inline bool algo::RnullStr36_Eq(algo::RnullStr36& lhs, algo::RnullStr36& rhs) {
10894 bool retval = true;
10895 retval = retval
10896 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
10897 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
10898 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
10899 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
10900 &&*(u32*)(lhs.ch+32) == *(u32*)(rhs.ch+32);
10901 return retval;
10902}
10903
10904// --- algo.RnullStr36..Update
10905// Set value. Return true if new value is different from old value.
10906inline bool algo::RnullStr36_Update(algo::RnullStr36 &lhs, algo::RnullStr36& rhs) {
10907 bool ret = !RnullStr36_Eq(lhs, rhs); // compare values
10908 if (ret) {
10909 lhs = rhs; // update
10910 }
10911 return ret;
10912}
10913
10914// --- algo.RnullStr36..EqStrptr
10915inline bool algo::RnullStr36_EqStrptr(const algo::RnullStr36& lhs, const algo::strptr& rhs) {
10916 return algo::strptr_Eq(ch_Getary(lhs), rhs);
10917}
10918inline algo::RnullStr4::RnullStr4() {
10919 algo::RnullStr4_Init(*this);
10920}
10921
10922
10923// --- algo.RnullStr4.ch.Getary
10924// Access string as array of chars
10925inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr4& parent) {
10926 int len = ch_N(parent);
10927 algo::aryptr<char> ret((char*)parent.ch, len);
10928 return ret;
10929}
10930
10931// --- algo.RnullStr4.ch.HashStrptr
10932inline u32 algo::RnullStr4_Hash(u32 prev, const algo::strptr &str) {
10933 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
10934}
10935
10936// --- algo.RnullStr4.ch.Init
10937inline void algo::ch_Init(algo::RnullStr4 &parent) {
10938 memset(parent.ch, 0, 4);
10939}
10940
10941// --- algo.RnullStr4.ch.Max
10942// always return constant 4
10943inline int algo::ch_Max(algo::RnullStr4& parent) {
10944 (void)parent;
10945 return 4;
10946}
10947
10948// --- algo.RnullStr4.ch.N
10949inline int algo::ch_N(const algo::RnullStr4& parent) {
10950 u64 ret;
10951 ret = 4;
10952 while (ret>0 && parent.ch[ret-1]==u8(0)) {
10953 ret--;
10954 }
10955 return int(ret);
10956}
10957
10958// --- algo.RnullStr4.ch.AssignStrptr
10959// Copy from strptr (operator=)
10960inline void algo::RnullStr4::operator =(const algo::strptr &str) {
10961 ch_SetStrptr(*this, str);
10962}
10963
10964// --- algo.RnullStr4.ch.Set
10965// Copy from same type
10966// Copy value from RHS.
10967inline void algo::RnullStr4::operator =(const algo::RnullStr4& parent) {
10968 memcpy(ch, parent.ch, 4);
10969}
10970
10971// --- algo.RnullStr4.ch.Ctor
10972inline algo::RnullStr4::RnullStr4(const algo::RnullStr4 &rhs) {
10973 operator =(rhs);
10974}
10975
10976// --- algo.RnullStr4.ch.CtorStrptr
10977inline algo::RnullStr4::RnullStr4(const algo::strptr &rhs) {
10978 ch_SetStrptr(*this, rhs);
10979}
10980
10981// --- algo.RnullStr4.ch.Cast
10982inline algo::RnullStr4::operator algo::strptr () const {
10983 return ch_Getary(*this);
10984}
10985
10986// --- algo.RnullStr4..Lt
10987inline bool algo::RnullStr4_Lt(algo::RnullStr4 lhs, algo::RnullStr4 rhs) {
10988 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
10989}
10990
10991// --- algo.RnullStr4..Cmp
10992inline i32 algo::RnullStr4_Cmp(algo::RnullStr4 lhs, algo::RnullStr4 rhs) {
10993 i32 retval = 0;
10994 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
10995 return retval;
10996}
10997
10998// --- algo.RnullStr4..Init
10999// Set all fields to initial values.
11000inline void algo::RnullStr4_Init(algo::RnullStr4& parent) {
11001 memset(parent.ch, 0, 4);
11002}
11003
11004// --- algo.RnullStr4..Eq
11005inline bool algo::RnullStr4_Eq(algo::RnullStr4 lhs, algo::RnullStr4 rhs) {
11006 bool retval = true;
11007 retval = retval
11008 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0);
11009 return retval;
11010}
11011
11012// --- algo.RnullStr4..Update
11013// Set value. Return true if new value is different from old value.
11014inline bool algo::RnullStr4_Update(algo::RnullStr4 &lhs, algo::RnullStr4 rhs) {
11015 bool ret = !RnullStr4_Eq(lhs, rhs); // compare values
11016 if (ret) {
11017 lhs = rhs; // update
11018 }
11019 return ret;
11020}
11021
11022// --- algo.RnullStr4..EqStrptr
11023inline bool algo::RnullStr4_EqStrptr(algo::RnullStr4 lhs, const algo::strptr& rhs) {
11024 return algo::strptr_Eq(ch_Getary(lhs), rhs);
11025}
11026
11027inline bool algo::RnullStr40::operator ==(const algo::RnullStr40 &rhs) const {
11028 return algo::RnullStr40_Eq(const_cast<algo::RnullStr40&>(*this),const_cast<algo::RnullStr40&>(rhs));
11029}
11030
11031inline bool algo::RnullStr40::operator !=(const algo::RnullStr40 &rhs) const {
11032 return !algo::RnullStr40_Eq(const_cast<algo::RnullStr40&>(*this),const_cast<algo::RnullStr40&>(rhs));
11033}
11034
11035inline bool algo::RnullStr40::operator ==(const algo::strptr &rhs) const {
11036 return algo::RnullStr40_EqStrptr(const_cast<algo::RnullStr40&>(*this),rhs);
11037}
11038
11039inline bool algo::RnullStr40::operator <(const algo::RnullStr40 &rhs) const {
11040 return algo::RnullStr40_Lt(const_cast<algo::RnullStr40&>(*this),const_cast<algo::RnullStr40&>(rhs));
11041}
11042
11043inline bool algo::RnullStr40::operator >(const algo::RnullStr40 &rhs) const {
11044 return rhs < *this;
11045}
11046
11047inline bool algo::RnullStr40::operator <=(const algo::RnullStr40 &rhs) const {
11048 return !(rhs < *this);
11049}
11050
11051inline bool algo::RnullStr40::operator >=(const algo::RnullStr40 &rhs) const {
11052 return !(*this < rhs);
11053}
11054inline algo::RnullStr40::RnullStr40() {
11055 algo::RnullStr40_Init(*this);
11056}
11057
11058
11059// --- algo.RnullStr40.ch.Getary
11060// Access string as array of chars
11061inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr40& parent) {
11062 int len = ch_N(parent);
11063 algo::aryptr<char> ret((char*)parent.ch, len);
11064 return ret;
11065}
11066
11067// --- algo.RnullStr40.ch.HashStrptr
11068inline u32 algo::RnullStr40_Hash(u32 prev, const algo::strptr &str) {
11069 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11070}
11071
11072// --- algo.RnullStr40.ch.Init
11073inline void algo::ch_Init(algo::RnullStr40 &parent) {
11074 memset(parent.ch, 0, 40);
11075}
11076
11077// --- algo.RnullStr40.ch.Max
11078// always return constant 40
11079inline int algo::ch_Max(algo::RnullStr40& parent) {
11080 (void)parent;
11081 return 40;
11082}
11083
11084// --- algo.RnullStr40.ch.N
11085inline int algo::ch_N(const algo::RnullStr40& parent) {
11086 u64 ret;
11087 ret = 40;
11088 while (ret>0 && parent.ch[ret-1]==u8(0)) {
11089 ret--;
11090 }
11091 return int(ret);
11092}
11093
11094// --- algo.RnullStr40.ch.AssignStrptr
11095// Copy from strptr (operator=)
11096inline void algo::RnullStr40::operator =(const algo::strptr &str) {
11097 ch_SetStrptr(*this, str);
11098}
11099
11100// --- algo.RnullStr40.ch.Set
11101// Copy from same type
11102// Copy value from RHS.
11103inline void algo::RnullStr40::operator =(const algo::RnullStr40& parent) {
11104 memcpy(ch, parent.ch, 40);
11105}
11106
11107// --- algo.RnullStr40.ch.Ctor
11108inline algo::RnullStr40::RnullStr40(const algo::RnullStr40 &rhs) {
11109 operator =(rhs);
11110}
11111
11112// --- algo.RnullStr40.ch.CtorStrptr
11113inline algo::RnullStr40::RnullStr40(const algo::strptr &rhs) {
11114 ch_SetStrptr(*this, rhs);
11115}
11116
11117// --- algo.RnullStr40.ch.Cast
11118inline algo::RnullStr40::operator algo::strptr () const {
11119 return ch_Getary(*this);
11120}
11121
11122// --- algo.RnullStr40..Lt
11123inline bool algo::RnullStr40_Lt(algo::RnullStr40& lhs, algo::RnullStr40& rhs) {
11124 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11125}
11126
11127// --- algo.RnullStr40..Cmp
11128inline i32 algo::RnullStr40_Cmp(algo::RnullStr40& lhs, algo::RnullStr40& rhs) {
11129 i32 retval = 0;
11130 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11131 return retval;
11132}
11133
11134// --- algo.RnullStr40..Init
11135// Set all fields to initial values.
11136inline void algo::RnullStr40_Init(algo::RnullStr40& parent) {
11137 memset(parent.ch, 0, 40);
11138}
11139
11140// --- algo.RnullStr40..Eq
11141inline bool algo::RnullStr40_Eq(algo::RnullStr40& lhs, algo::RnullStr40& rhs) {
11142 bool retval = true;
11143 retval = retval
11144 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11145 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11146 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11147 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11148 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32);
11149 return retval;
11150}
11151
11152// --- algo.RnullStr40..Update
11153// Set value. Return true if new value is different from old value.
11154inline bool algo::RnullStr40_Update(algo::RnullStr40 &lhs, algo::RnullStr40& rhs) {
11155 bool ret = !RnullStr40_Eq(lhs, rhs); // compare values
11156 if (ret) {
11157 lhs = rhs; // update
11158 }
11159 return ret;
11160}
11161
11162// --- algo.RnullStr40..EqStrptr
11163inline bool algo::RnullStr40_EqStrptr(const algo::RnullStr40& lhs, const algo::strptr& rhs) {
11164 return algo::strptr_Eq(ch_Getary(lhs), rhs);
11165}
11166
11167inline bool algo::RnullStr41::operator ==(const algo::RnullStr41 &rhs) const {
11168 return algo::RnullStr41_Eq(const_cast<algo::RnullStr41&>(*this),const_cast<algo::RnullStr41&>(rhs));
11169}
11170
11171inline bool algo::RnullStr41::operator !=(const algo::RnullStr41 &rhs) const {
11172 return !algo::RnullStr41_Eq(const_cast<algo::RnullStr41&>(*this),const_cast<algo::RnullStr41&>(rhs));
11173}
11174
11175inline bool algo::RnullStr41::operator ==(const algo::strptr &rhs) const {
11176 return algo::RnullStr41_EqStrptr(const_cast<algo::RnullStr41&>(*this),rhs);
11177}
11178
11179inline bool algo::RnullStr41::operator <(const algo::RnullStr41 &rhs) const {
11180 return algo::RnullStr41_Lt(const_cast<algo::RnullStr41&>(*this),const_cast<algo::RnullStr41&>(rhs));
11181}
11182
11183inline bool algo::RnullStr41::operator >(const algo::RnullStr41 &rhs) const {
11184 return rhs < *this;
11185}
11186
11187inline bool algo::RnullStr41::operator <=(const algo::RnullStr41 &rhs) const {
11188 return !(rhs < *this);
11189}
11190
11191inline bool algo::RnullStr41::operator >=(const algo::RnullStr41 &rhs) const {
11192 return !(*this < rhs);
11193}
11194inline algo::RnullStr41::RnullStr41() {
11195 algo::RnullStr41_Init(*this);
11196}
11197
11198
11199// --- algo.RnullStr41.ch.Getary
11200// Access string as array of chars
11201inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr41& parent) {
11202 int len = ch_N(parent);
11203 algo::aryptr<char> ret((char*)parent.ch, len);
11204 return ret;
11205}
11206
11207// --- algo.RnullStr41.ch.HashStrptr
11208inline u32 algo::RnullStr41_Hash(u32 prev, const algo::strptr &str) {
11209 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11210}
11211
11212// --- algo.RnullStr41.ch.Init
11213inline void algo::ch_Init(algo::RnullStr41 &parent) {
11214 memset(parent.ch, 0, 41);
11215}
11216
11217// --- algo.RnullStr41.ch.Max
11218// always return constant 41
11219inline int algo::ch_Max(algo::RnullStr41& parent) {
11220 (void)parent;
11221 return 41;
11222}
11223
11224// --- algo.RnullStr41.ch.N
11225inline int algo::ch_N(const algo::RnullStr41& parent) {
11226 u64 ret;
11227 ret = 41;
11228 while (ret>0 && parent.ch[ret-1]==u8(0)) {
11229 ret--;
11230 }
11231 return int(ret);
11232}
11233
11234// --- algo.RnullStr41.ch.AssignStrptr
11235// Copy from strptr (operator=)
11236inline void algo::RnullStr41::operator =(const algo::strptr &str) {
11237 ch_SetStrptr(*this, str);
11238}
11239
11240// --- algo.RnullStr41.ch.Set
11241// Copy from same type
11242// Copy value from RHS.
11243inline void algo::RnullStr41::operator =(const algo::RnullStr41& parent) {
11244 memcpy(ch, parent.ch, 41);
11245}
11246
11247// --- algo.RnullStr41.ch.Ctor
11248inline algo::RnullStr41::RnullStr41(const algo::RnullStr41 &rhs) {
11249 operator =(rhs);
11250}
11251
11252// --- algo.RnullStr41.ch.CtorStrptr
11253inline algo::RnullStr41::RnullStr41(const algo::strptr &rhs) {
11254 ch_SetStrptr(*this, rhs);
11255}
11256
11257// --- algo.RnullStr41.ch.Cast
11258inline algo::RnullStr41::operator algo::strptr () const {
11259 return ch_Getary(*this);
11260}
11261
11262// --- algo.RnullStr41..Lt
11263inline bool algo::RnullStr41_Lt(algo::RnullStr41& lhs, algo::RnullStr41& rhs) {
11264 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11265}
11266
11267// --- algo.RnullStr41..Cmp
11268inline i32 algo::RnullStr41_Cmp(algo::RnullStr41& lhs, algo::RnullStr41& rhs) {
11269 i32 retval = 0;
11270 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11271 return retval;
11272}
11273
11274// --- algo.RnullStr41..Init
11275// Set all fields to initial values.
11276inline void algo::RnullStr41_Init(algo::RnullStr41& parent) {
11277 memset(parent.ch, 0, 41);
11278}
11279
11280// --- algo.RnullStr41..Eq
11281inline bool algo::RnullStr41_Eq(algo::RnullStr41& lhs, algo::RnullStr41& rhs) {
11282 bool retval = true;
11283 retval = retval
11284 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11285 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11286 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11287 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11288 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11289 &&*(u8*)(lhs.ch+40) == *(u8*)(rhs.ch+40);
11290 return retval;
11291}
11292
11293// --- algo.RnullStr41..Update
11294// Set value. Return true if new value is different from old value.
11295inline bool algo::RnullStr41_Update(algo::RnullStr41 &lhs, algo::RnullStr41& rhs) {
11296 bool ret = !RnullStr41_Eq(lhs, rhs); // compare values
11297 if (ret) {
11298 lhs = rhs; // update
11299 }
11300 return ret;
11301}
11302
11303// --- algo.RnullStr41..EqStrptr
11304inline bool algo::RnullStr41_EqStrptr(const algo::RnullStr41& lhs, const algo::strptr& rhs) {
11305 return algo::strptr_Eq(ch_Getary(lhs), rhs);
11306}
11307inline algo::RnullStr43::RnullStr43() {
11308 algo::RnullStr43_Init(*this);
11309}
11310
11311
11312// --- algo.RnullStr43.ch.Getary
11313// Access string as array of chars
11314inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr43& parent) {
11315 int len = ch_N(parent);
11316 algo::aryptr<char> ret((char*)parent.ch, len);
11317 return ret;
11318}
11319
11320// --- algo.RnullStr43.ch.HashStrptr
11321inline u32 algo::RnullStr43_Hash(u32 prev, const algo::strptr &str) {
11322 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11323}
11324
11325// --- algo.RnullStr43.ch.Init
11326inline void algo::ch_Init(algo::RnullStr43 &parent) {
11327 memset(parent.ch, 0, 43);
11328}
11329
11330// --- algo.RnullStr43.ch.Max
11331// always return constant 43
11332inline int algo::ch_Max(algo::RnullStr43& parent) {
11333 (void)parent;
11334 return 43;
11335}
11336
11337// --- algo.RnullStr43.ch.N
11338inline int algo::ch_N(const algo::RnullStr43& parent) {
11339 u64 ret;
11340 ret = 43;
11341 while (ret>0 && parent.ch[ret-1]==u8(0)) {
11342 ret--;
11343 }
11344 return int(ret);
11345}
11346
11347// --- algo.RnullStr43.ch.AssignStrptr
11348// Copy from strptr (operator=)
11349inline void algo::RnullStr43::operator =(const algo::strptr &str) {
11350 ch_SetStrptr(*this, str);
11351}
11352
11353// --- algo.RnullStr43.ch.Set
11354// Copy from same type
11355// Copy value from RHS.
11356inline void algo::RnullStr43::operator =(const algo::RnullStr43& parent) {
11357 memcpy(ch, parent.ch, 43);
11358}
11359
11360// --- algo.RnullStr43.ch.Ctor
11361inline algo::RnullStr43::RnullStr43(const algo::RnullStr43 &rhs) {
11362 operator =(rhs);
11363}
11364
11365// --- algo.RnullStr43.ch.CtorStrptr
11366inline algo::RnullStr43::RnullStr43(const algo::strptr &rhs) {
11367 ch_SetStrptr(*this, rhs);
11368}
11369
11370// --- algo.RnullStr43.ch.Cast
11371inline algo::RnullStr43::operator algo::strptr () const {
11372 return ch_Getary(*this);
11373}
11374
11375// --- algo.RnullStr43..Lt
11376inline bool algo::RnullStr43_Lt(algo::RnullStr43& lhs, algo::RnullStr43& rhs) {
11377 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11378}
11379
11380// --- algo.RnullStr43..Cmp
11381inline i32 algo::RnullStr43_Cmp(algo::RnullStr43& lhs, algo::RnullStr43& rhs) {
11382 i32 retval = 0;
11383 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11384 return retval;
11385}
11386
11387// --- algo.RnullStr43..Init
11388// Set all fields to initial values.
11389inline void algo::RnullStr43_Init(algo::RnullStr43& parent) {
11390 memset(parent.ch, 0, 43);
11391}
11392
11393// --- algo.RnullStr43..Eq
11394inline bool algo::RnullStr43_Eq(algo::RnullStr43& lhs, algo::RnullStr43& rhs) {
11395 bool retval = true;
11396 retval = retval
11397 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11398 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11399 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11400 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11401 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11402 &&*(u16*)(lhs.ch+40) == *(u16*)(rhs.ch+40)
11403 &&*(u8*)(lhs.ch+42) == *(u8*)(rhs.ch+42);
11404 return retval;
11405}
11406
11407// --- algo.RnullStr43..Update
11408// Set value. Return true if new value is different from old value.
11409inline bool algo::RnullStr43_Update(algo::RnullStr43 &lhs, algo::RnullStr43& rhs) {
11410 bool ret = !RnullStr43_Eq(lhs, rhs); // compare values
11411 if (ret) {
11412 lhs = rhs; // update
11413 }
11414 return ret;
11415}
11416
11417// --- algo.RnullStr43..EqStrptr
11418inline bool algo::RnullStr43_EqStrptr(const algo::RnullStr43& lhs, const algo::strptr& rhs) {
11419 return algo::strptr_Eq(ch_Getary(lhs), rhs);
11420}
11421inline algo::RnullStr44::RnullStr44() {
11422 algo::RnullStr44_Init(*this);
11423}
11424
11425
11426// --- algo.RnullStr44.ch.Getary
11427// Access string as array of chars
11428inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr44& parent) {
11429 int len = ch_N(parent);
11430 algo::aryptr<char> ret((char*)parent.ch, len);
11431 return ret;
11432}
11433
11434// --- algo.RnullStr44.ch.HashStrptr
11435inline u32 algo::RnullStr44_Hash(u32 prev, const algo::strptr &str) {
11436 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11437}
11438
11439// --- algo.RnullStr44.ch.Init
11440inline void algo::ch_Init(algo::RnullStr44 &parent) {
11441 memset(parent.ch, 0, 44);
11442}
11443
11444// --- algo.RnullStr44.ch.Max
11445// always return constant 44
11446inline int algo::ch_Max(algo::RnullStr44& parent) {
11447 (void)parent;
11448 return 44;
11449}
11450
11451// --- algo.RnullStr44.ch.N
11452inline int algo::ch_N(const algo::RnullStr44& parent) {
11453 u64 ret;
11454 ret = 44;
11455 while (ret>0 && parent.ch[ret-1]==u8(0)) {
11456 ret--;
11457 }
11458 return int(ret);
11459}
11460
11461// --- algo.RnullStr44.ch.AssignStrptr
11462// Copy from strptr (operator=)
11463inline void algo::RnullStr44::operator =(const algo::strptr &str) {
11464 ch_SetStrptr(*this, str);
11465}
11466
11467// --- algo.RnullStr44.ch.Set
11468// Copy from same type
11469// Copy value from RHS.
11470inline void algo::RnullStr44::operator =(const algo::RnullStr44& parent) {
11471 memcpy(ch, parent.ch, 44);
11472}
11473
11474// --- algo.RnullStr44.ch.Ctor
11475inline algo::RnullStr44::RnullStr44(const algo::RnullStr44 &rhs) {
11476 operator =(rhs);
11477}
11478
11479// --- algo.RnullStr44.ch.CtorStrptr
11480inline algo::RnullStr44::RnullStr44(const algo::strptr &rhs) {
11481 ch_SetStrptr(*this, rhs);
11482}
11483
11484// --- algo.RnullStr44.ch.Cast
11485inline algo::RnullStr44::operator algo::strptr () const {
11486 return ch_Getary(*this);
11487}
11488
11489// --- algo.RnullStr44..Lt
11490inline bool algo::RnullStr44_Lt(algo::RnullStr44& lhs, algo::RnullStr44& rhs) {
11491 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11492}
11493
11494// --- algo.RnullStr44..Cmp
11495inline i32 algo::RnullStr44_Cmp(algo::RnullStr44& lhs, algo::RnullStr44& rhs) {
11496 i32 retval = 0;
11497 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11498 return retval;
11499}
11500
11501// --- algo.RnullStr44..Init
11502// Set all fields to initial values.
11503inline void algo::RnullStr44_Init(algo::RnullStr44& parent) {
11504 memset(parent.ch, 0, 44);
11505}
11506
11507// --- algo.RnullStr44..Eq
11508inline bool algo::RnullStr44_Eq(algo::RnullStr44& lhs, algo::RnullStr44& rhs) {
11509 bool retval = true;
11510 retval = retval
11511 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11512 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11513 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11514 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11515 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11516 &&*(u32*)(lhs.ch+40) == *(u32*)(rhs.ch+40);
11517 return retval;
11518}
11519
11520// --- algo.RnullStr44..Update
11521// Set value. Return true if new value is different from old value.
11522inline bool algo::RnullStr44_Update(algo::RnullStr44 &lhs, algo::RnullStr44& rhs) {
11523 bool ret = !RnullStr44_Eq(lhs, rhs); // compare values
11524 if (ret) {
11525 lhs = rhs; // update
11526 }
11527 return ret;
11528}
11529
11530// --- algo.RnullStr44..EqStrptr
11531inline bool algo::RnullStr44_EqStrptr(const algo::RnullStr44& lhs, const algo::strptr& rhs) {
11532 return algo::strptr_Eq(ch_Getary(lhs), rhs);
11533}
11534inline algo::RnullStr48::RnullStr48() {
11535 algo::RnullStr48_Init(*this);
11536}
11537
11538
11539// --- algo.RnullStr48.ch.Getary
11540// Access string as array of chars
11541inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr48& parent) {
11542 int len = ch_N(parent);
11543 algo::aryptr<char> ret((char*)parent.ch, len);
11544 return ret;
11545}
11546
11547// --- algo.RnullStr48.ch.HashStrptr
11548inline u32 algo::RnullStr48_Hash(u32 prev, const algo::strptr &str) {
11549 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11550}
11551
11552// --- algo.RnullStr48.ch.Init
11553inline void algo::ch_Init(algo::RnullStr48 &parent) {
11554 memset(parent.ch, 0, 48);
11555}
11556
11557// --- algo.RnullStr48.ch.Max
11558// always return constant 48
11559inline int algo::ch_Max(algo::RnullStr48& parent) {
11560 (void)parent;
11561 return 48;
11562}
11563
11564// --- algo.RnullStr48.ch.N
11565inline int algo::ch_N(const algo::RnullStr48& parent) {
11566 u64 ret;
11567 ret = 48;
11568 while (ret>0 && parent.ch[ret-1]==u8(0)) {
11569 ret--;
11570 }
11571 return int(ret);
11572}
11573
11574// --- algo.RnullStr48.ch.AssignStrptr
11575// Copy from strptr (operator=)
11576inline void algo::RnullStr48::operator =(const algo::strptr &str) {
11577 ch_SetStrptr(*this, str);
11578}
11579
11580// --- algo.RnullStr48.ch.Set
11581// Copy from same type
11582// Copy value from RHS.
11583inline void algo::RnullStr48::operator =(const algo::RnullStr48& parent) {
11584 memcpy(ch, parent.ch, 48);
11585}
11586
11587// --- algo.RnullStr48.ch.Ctor
11588inline algo::RnullStr48::RnullStr48(const algo::RnullStr48 &rhs) {
11589 operator =(rhs);
11590}
11591
11592// --- algo.RnullStr48.ch.CtorStrptr
11593inline algo::RnullStr48::RnullStr48(const algo::strptr &rhs) {
11594 ch_SetStrptr(*this, rhs);
11595}
11596
11597// --- algo.RnullStr48.ch.Cast
11598inline algo::RnullStr48::operator algo::strptr () const {
11599 return ch_Getary(*this);
11600}
11601
11602// --- algo.RnullStr48..Lt
11603inline bool algo::RnullStr48_Lt(algo::RnullStr48& lhs, algo::RnullStr48& rhs) {
11604 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11605}
11606
11607// --- algo.RnullStr48..Cmp
11608inline i32 algo::RnullStr48_Cmp(algo::RnullStr48& lhs, algo::RnullStr48& rhs) {
11609 i32 retval = 0;
11610 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11611 return retval;
11612}
11613
11614// --- algo.RnullStr48..Init
11615// Set all fields to initial values.
11616inline void algo::RnullStr48_Init(algo::RnullStr48& parent) {
11617 memset(parent.ch, 0, 48);
11618}
11619
11620// --- algo.RnullStr48..Eq
11621inline bool algo::RnullStr48_Eq(algo::RnullStr48& lhs, algo::RnullStr48& rhs) {
11622 bool retval = true;
11623 retval = retval
11624 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11625 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11626 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11627 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11628 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11629 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40);
11630 return retval;
11631}
11632
11633// --- algo.RnullStr48..Update
11634// Set value. Return true if new value is different from old value.
11635inline bool algo::RnullStr48_Update(algo::RnullStr48 &lhs, algo::RnullStr48& rhs) {
11636 bool ret = !RnullStr48_Eq(lhs, rhs); // compare values
11637 if (ret) {
11638 lhs = rhs; // update
11639 }
11640 return ret;
11641}
11642
11643// --- algo.RnullStr48..EqStrptr
11644inline bool algo::RnullStr48_EqStrptr(const algo::RnullStr48& lhs, const algo::strptr& rhs) {
11645 return algo::strptr_Eq(ch_Getary(lhs), rhs);
11646}
11647inline algo::RnullStr5::RnullStr5() {
11648 algo::RnullStr5_Init(*this);
11649}
11650
11651
11652// --- algo.RnullStr5.ch.Getary
11653// Access string as array of chars
11654inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr5& parent) {
11655 int len = ch_N(parent);
11656 algo::aryptr<char> ret((char*)parent.ch, len);
11657 return ret;
11658}
11659
11660// --- algo.RnullStr5.ch.HashStrptr
11661inline u32 algo::RnullStr5_Hash(u32 prev, const algo::strptr &str) {
11662 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11663}
11664
11665// --- algo.RnullStr5.ch.Init
11666inline void algo::ch_Init(algo::RnullStr5 &parent) {
11667 memset(parent.ch, 0, 5);
11668}
11669
11670// --- algo.RnullStr5.ch.Max
11671// always return constant 5
11672inline int algo::ch_Max(algo::RnullStr5& parent) {
11673 (void)parent;
11674 return 5;
11675}
11676
11677// --- algo.RnullStr5.ch.N
11678inline int algo::ch_N(const algo::RnullStr5& parent) {
11679 u64 ret;
11680 ret = 5;
11681 while (ret>0 && parent.ch[ret-1]==u8(0)) {
11682 ret--;
11683 }
11684 return int(ret);
11685}
11686
11687// --- algo.RnullStr5.ch.AssignStrptr
11688// Copy from strptr (operator=)
11689inline void algo::RnullStr5::operator =(const algo::strptr &str) {
11690 ch_SetStrptr(*this, str);
11691}
11692
11693// --- algo.RnullStr5.ch.Set
11694// Copy from same type
11695// Copy value from RHS.
11696inline void algo::RnullStr5::operator =(const algo::RnullStr5& parent) {
11697 memcpy(ch, parent.ch, 5);
11698}
11699
11700// --- algo.RnullStr5.ch.Ctor
11701inline algo::RnullStr5::RnullStr5(const algo::RnullStr5 &rhs) {
11702 operator =(rhs);
11703}
11704
11705// --- algo.RnullStr5.ch.CtorStrptr
11706inline algo::RnullStr5::RnullStr5(const algo::strptr &rhs) {
11707 ch_SetStrptr(*this, rhs);
11708}
11709
11710// --- algo.RnullStr5.ch.Cast
11711inline algo::RnullStr5::operator algo::strptr () const {
11712 return ch_Getary(*this);
11713}
11714
11715// --- algo.RnullStr5..Lt
11716inline bool algo::RnullStr5_Lt(algo::RnullStr5 lhs, algo::RnullStr5 rhs) {
11717 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11718}
11719
11720// --- algo.RnullStr5..Cmp
11721inline i32 algo::RnullStr5_Cmp(algo::RnullStr5 lhs, algo::RnullStr5 rhs) {
11722 i32 retval = 0;
11723 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11724 return retval;
11725}
11726
11727// --- algo.RnullStr5..Init
11728// Set all fields to initial values.
11729inline void algo::RnullStr5_Init(algo::RnullStr5& parent) {
11730 memset(parent.ch, 0, 5);
11731}
11732
11733// --- algo.RnullStr5..Eq
11734inline bool algo::RnullStr5_Eq(algo::RnullStr5 lhs, algo::RnullStr5 rhs) {
11735 bool retval = true;
11736 retval = retval
11737 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
11738 &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
11739 return retval;
11740}
11741
11742// --- algo.RnullStr5..Update
11743// Set value. Return true if new value is different from old value.
11744inline bool algo::RnullStr5_Update(algo::RnullStr5 &lhs, algo::RnullStr5 rhs) {
11745 bool ret = !RnullStr5_Eq(lhs, rhs); // compare values
11746 if (ret) {
11747 lhs = rhs; // update
11748 }
11749 return ret;
11750}
11751
11752// --- algo.RnullStr5..EqStrptr
11753inline bool algo::RnullStr5_EqStrptr(algo::RnullStr5 lhs, const algo::strptr& rhs) {
11754 return algo::strptr_Eq(ch_Getary(lhs), rhs);
11755}
11756inline algo::RnullStr50::RnullStr50() {
11757 algo::RnullStr50_Init(*this);
11758}
11759
11760
11761// --- algo.RnullStr50.ch.Getary
11762// Access string as array of chars
11763inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr50& parent) {
11764 int len = ch_N(parent);
11765 algo::aryptr<char> ret((char*)parent.ch, len);
11766 return ret;
11767}
11768
11769// --- algo.RnullStr50.ch.HashStrptr
11770inline u32 algo::RnullStr50_Hash(u32 prev, const algo::strptr &str) {
11771 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11772}
11773
11774// --- algo.RnullStr50.ch.Init
11775inline void algo::ch_Init(algo::RnullStr50 &parent) {
11776 memset(parent.ch, 0, 50);
11777}
11778
11779// --- algo.RnullStr50.ch.Max
11780// always return constant 50
11781inline int algo::ch_Max(algo::RnullStr50& parent) {
11782 (void)parent;
11783 return 50;
11784}
11785
11786// --- algo.RnullStr50.ch.N
11787inline int algo::ch_N(const algo::RnullStr50& parent) {
11788 u64 ret;
11789 ret = 50;
11790 while (ret>0 && parent.ch[ret-1]==u8(0)) {
11791 ret--;
11792 }
11793 return int(ret);
11794}
11795
11796// --- algo.RnullStr50.ch.AssignStrptr
11797// Copy from strptr (operator=)
11798inline void algo::RnullStr50::operator =(const algo::strptr &str) {
11799 ch_SetStrptr(*this, str);
11800}
11801
11802// --- algo.RnullStr50.ch.Set
11803// Copy from same type
11804// Copy value from RHS.
11805inline void algo::RnullStr50::operator =(const algo::RnullStr50& parent) {
11806 memcpy(ch, parent.ch, 50);
11807}
11808
11809// --- algo.RnullStr50.ch.Ctor
11810inline algo::RnullStr50::RnullStr50(const algo::RnullStr50 &rhs) {
11811 operator =(rhs);
11812}
11813
11814// --- algo.RnullStr50.ch.CtorStrptr
11815inline algo::RnullStr50::RnullStr50(const algo::strptr &rhs) {
11816 ch_SetStrptr(*this, rhs);
11817}
11818
11819// --- algo.RnullStr50.ch.Cast
11820inline algo::RnullStr50::operator algo::strptr () const {
11821 return ch_Getary(*this);
11822}
11823
11824// --- algo.RnullStr50..Lt
11825inline bool algo::RnullStr50_Lt(algo::RnullStr50& lhs, algo::RnullStr50& rhs) {
11826 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11827}
11828
11829// --- algo.RnullStr50..Cmp
11830inline i32 algo::RnullStr50_Cmp(algo::RnullStr50& lhs, algo::RnullStr50& rhs) {
11831 i32 retval = 0;
11832 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11833 return retval;
11834}
11835
11836// --- algo.RnullStr50..Init
11837// Set all fields to initial values.
11838inline void algo::RnullStr50_Init(algo::RnullStr50& parent) {
11839 memset(parent.ch, 0, 50);
11840}
11841
11842// --- algo.RnullStr50..Eq
11843inline bool algo::RnullStr50_Eq(algo::RnullStr50& lhs, algo::RnullStr50& rhs) {
11844 bool retval = true;
11845 retval = retval
11846 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11847 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11848 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11849 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11850 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11851 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
11852 &&*(u16*)(lhs.ch+48) == *(u16*)(rhs.ch+48);
11853 return retval;
11854}
11855
11856// --- algo.RnullStr50..Update
11857// Set value. Return true if new value is different from old value.
11858inline bool algo::RnullStr50_Update(algo::RnullStr50 &lhs, algo::RnullStr50& rhs) {
11859 bool ret = !RnullStr50_Eq(lhs, rhs); // compare values
11860 if (ret) {
11861 lhs = rhs; // update
11862 }
11863 return ret;
11864}
11865
11866// --- algo.RnullStr50..EqStrptr
11867inline bool algo::RnullStr50_EqStrptr(const algo::RnullStr50& lhs, const algo::strptr& rhs) {
11868 return algo::strptr_Eq(ch_Getary(lhs), rhs);
11869}
11870
11871inline bool algo::RnullStr54::operator ==(const algo::RnullStr54 &rhs) const {
11872 return algo::RnullStr54_Eq(const_cast<algo::RnullStr54&>(*this),const_cast<algo::RnullStr54&>(rhs));
11873}
11874
11875inline bool algo::RnullStr54::operator !=(const algo::RnullStr54 &rhs) const {
11876 return !algo::RnullStr54_Eq(const_cast<algo::RnullStr54&>(*this),const_cast<algo::RnullStr54&>(rhs));
11877}
11878
11879inline bool algo::RnullStr54::operator ==(const algo::strptr &rhs) const {
11880 return algo::RnullStr54_EqStrptr(const_cast<algo::RnullStr54&>(*this),rhs);
11881}
11882
11883inline bool algo::RnullStr54::operator <(const algo::RnullStr54 &rhs) const {
11884 return algo::RnullStr54_Lt(const_cast<algo::RnullStr54&>(*this),const_cast<algo::RnullStr54&>(rhs));
11885}
11886
11887inline bool algo::RnullStr54::operator >(const algo::RnullStr54 &rhs) const {
11888 return rhs < *this;
11889}
11890
11891inline bool algo::RnullStr54::operator <=(const algo::RnullStr54 &rhs) const {
11892 return !(rhs < *this);
11893}
11894
11895inline bool algo::RnullStr54::operator >=(const algo::RnullStr54 &rhs) const {
11896 return !(*this < rhs);
11897}
11898inline algo::RnullStr54::RnullStr54() {
11899 algo::RnullStr54_Init(*this);
11900}
11901
11902
11903// --- algo.RnullStr54.ch.Getary
11904// Access string as array of chars
11905inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr54& parent) {
11906 int len = ch_N(parent);
11907 algo::aryptr<char> ret((char*)parent.ch, len);
11908 return ret;
11909}
11910
11911// --- algo.RnullStr54.ch.HashStrptr
11912inline u32 algo::RnullStr54_Hash(u32 prev, const algo::strptr &str) {
11913 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
11914}
11915
11916// --- algo.RnullStr54.ch.Init
11917inline void algo::ch_Init(algo::RnullStr54 &parent) {
11918 memset(parent.ch, 0, 54);
11919}
11920
11921// --- algo.RnullStr54.ch.Max
11922// always return constant 54
11923inline int algo::ch_Max(algo::RnullStr54& parent) {
11924 (void)parent;
11925 return 54;
11926}
11927
11928// --- algo.RnullStr54.ch.N
11929inline int algo::ch_N(const algo::RnullStr54& parent) {
11930 u64 ret;
11931 ret = 54;
11932 while (ret>0 && parent.ch[ret-1]==u8(0)) {
11933 ret--;
11934 }
11935 return int(ret);
11936}
11937
11938// --- algo.RnullStr54.ch.AssignStrptr
11939// Copy from strptr (operator=)
11940inline void algo::RnullStr54::operator =(const algo::strptr &str) {
11941 ch_SetStrptr(*this, str);
11942}
11943
11944// --- algo.RnullStr54.ch.Set
11945// Copy from same type
11946// Copy value from RHS.
11947inline void algo::RnullStr54::operator =(const algo::RnullStr54& parent) {
11948 memcpy(ch, parent.ch, 54);
11949}
11950
11951// --- algo.RnullStr54.ch.Ctor
11952inline algo::RnullStr54::RnullStr54(const algo::RnullStr54 &rhs) {
11953 operator =(rhs);
11954}
11955
11956// --- algo.RnullStr54.ch.CtorStrptr
11957inline algo::RnullStr54::RnullStr54(const algo::strptr &rhs) {
11958 ch_SetStrptr(*this, rhs);
11959}
11960
11961// --- algo.RnullStr54.ch.Cast
11962inline algo::RnullStr54::operator algo::strptr () const {
11963 return ch_Getary(*this);
11964}
11965
11966// --- algo.RnullStr54..Lt
11967inline bool algo::RnullStr54_Lt(algo::RnullStr54& lhs, algo::RnullStr54& rhs) {
11968 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
11969}
11970
11971// --- algo.RnullStr54..Cmp
11972inline i32 algo::RnullStr54_Cmp(algo::RnullStr54& lhs, algo::RnullStr54& rhs) {
11973 i32 retval = 0;
11974 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
11975 return retval;
11976}
11977
11978// --- algo.RnullStr54..Init
11979// Set all fields to initial values.
11980inline void algo::RnullStr54_Init(algo::RnullStr54& parent) {
11981 memset(parent.ch, 0, 54);
11982}
11983
11984// --- algo.RnullStr54..Eq
11985inline bool algo::RnullStr54_Eq(algo::RnullStr54& lhs, algo::RnullStr54& rhs) {
11986 bool retval = true;
11987 retval = retval
11988 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
11989 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
11990 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
11991 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
11992 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
11993 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
11994 &&*(u32*)(lhs.ch+48) == *(u32*)(rhs.ch+48)
11995 &&*(u16*)(lhs.ch+52) == *(u16*)(rhs.ch+52);
11996 return retval;
11997}
11998
11999// --- algo.RnullStr54..Update
12000// Set value. Return true if new value is different from old value.
12001inline bool algo::RnullStr54_Update(algo::RnullStr54 &lhs, algo::RnullStr54& rhs) {
12002 bool ret = !RnullStr54_Eq(lhs, rhs); // compare values
12003 if (ret) {
12004 lhs = rhs; // update
12005 }
12006 return ret;
12007}
12008
12009// --- algo.RnullStr54..EqStrptr
12010inline bool algo::RnullStr54_EqStrptr(const algo::RnullStr54& lhs, const algo::strptr& rhs) {
12011 return algo::strptr_Eq(ch_Getary(lhs), rhs);
12012}
12013inline algo::RnullStr55::RnullStr55() {
12014 algo::RnullStr55_Init(*this);
12015}
12016
12017
12018// --- algo.RnullStr55.ch.Getary
12019// Access string as array of chars
12020inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr55& parent) {
12021 int len = ch_N(parent);
12022 algo::aryptr<char> ret((char*)parent.ch, len);
12023 return ret;
12024}
12025
12026// --- algo.RnullStr55.ch.HashStrptr
12027inline u32 algo::RnullStr55_Hash(u32 prev, const algo::strptr &str) {
12028 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12029}
12030
12031// --- algo.RnullStr55.ch.Init
12032inline void algo::ch_Init(algo::RnullStr55 &parent) {
12033 memset(parent.ch, 0, 55);
12034}
12035
12036// --- algo.RnullStr55.ch.Max
12037// always return constant 55
12038inline int algo::ch_Max(algo::RnullStr55& parent) {
12039 (void)parent;
12040 return 55;
12041}
12042
12043// --- algo.RnullStr55.ch.N
12044inline int algo::ch_N(const algo::RnullStr55& parent) {
12045 u64 ret;
12046 ret = 55;
12047 while (ret>0 && parent.ch[ret-1]==u8(0)) {
12048 ret--;
12049 }
12050 return int(ret);
12051}
12052
12053// --- algo.RnullStr55.ch.AssignStrptr
12054// Copy from strptr (operator=)
12055inline void algo::RnullStr55::operator =(const algo::strptr &str) {
12056 ch_SetStrptr(*this, str);
12057}
12058
12059// --- algo.RnullStr55.ch.Set
12060// Copy from same type
12061// Copy value from RHS.
12062inline void algo::RnullStr55::operator =(const algo::RnullStr55& parent) {
12063 memcpy(ch, parent.ch, 55);
12064}
12065
12066// --- algo.RnullStr55.ch.Ctor
12067inline algo::RnullStr55::RnullStr55(const algo::RnullStr55 &rhs) {
12068 operator =(rhs);
12069}
12070
12071// --- algo.RnullStr55.ch.CtorStrptr
12072inline algo::RnullStr55::RnullStr55(const algo::strptr &rhs) {
12073 ch_SetStrptr(*this, rhs);
12074}
12075
12076// --- algo.RnullStr55.ch.Cast
12077inline algo::RnullStr55::operator algo::strptr () const {
12078 return ch_Getary(*this);
12079}
12080
12081// --- algo.RnullStr55..Lt
12082inline bool algo::RnullStr55_Lt(algo::RnullStr55& lhs, algo::RnullStr55& rhs) {
12083 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12084}
12085
12086// --- algo.RnullStr55..Cmp
12087inline i32 algo::RnullStr55_Cmp(algo::RnullStr55& lhs, algo::RnullStr55& rhs) {
12088 i32 retval = 0;
12089 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12090 return retval;
12091}
12092
12093// --- algo.RnullStr55..Init
12094// Set all fields to initial values.
12095inline void algo::RnullStr55_Init(algo::RnullStr55& parent) {
12096 memset(parent.ch, 0, 55);
12097}
12098
12099// --- algo.RnullStr55..Eq
12100inline bool algo::RnullStr55_Eq(algo::RnullStr55& lhs, algo::RnullStr55& rhs) {
12101 bool retval = true;
12102 retval = retval
12103 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
12104 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
12105 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
12106 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
12107 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
12108 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
12109 &&*(u32*)(lhs.ch+48) == *(u32*)(rhs.ch+48)
12110 &&*(u16*)(lhs.ch+52) == *(u16*)(rhs.ch+52)
12111 &&*(u8*)(lhs.ch+54) == *(u8*)(rhs.ch+54);
12112 return retval;
12113}
12114
12115// --- algo.RnullStr55..Update
12116// Set value. Return true if new value is different from old value.
12117inline bool algo::RnullStr55_Update(algo::RnullStr55 &lhs, algo::RnullStr55& rhs) {
12118 bool ret = !RnullStr55_Eq(lhs, rhs); // compare values
12119 if (ret) {
12120 lhs = rhs; // update
12121 }
12122 return ret;
12123}
12124
12125// --- algo.RnullStr55..EqStrptr
12126inline bool algo::RnullStr55_EqStrptr(const algo::RnullStr55& lhs, const algo::strptr& rhs) {
12127 return algo::strptr_Eq(ch_Getary(lhs), rhs);
12128}
12129
12130inline bool algo::RnullStr6::operator ==(const algo::RnullStr6 &rhs) const {
12131 return algo::RnullStr6_Eq(const_cast<algo::RnullStr6&>(*this),const_cast<algo::RnullStr6&>(rhs));
12132}
12133
12134inline bool algo::RnullStr6::operator !=(const algo::RnullStr6 &rhs) const {
12135 return !algo::RnullStr6_Eq(const_cast<algo::RnullStr6&>(*this),const_cast<algo::RnullStr6&>(rhs));
12136}
12137
12138inline bool algo::RnullStr6::operator ==(const algo::strptr &rhs) const {
12139 return algo::RnullStr6_EqStrptr(const_cast<algo::RnullStr6&>(*this),rhs);
12140}
12141
12142inline bool algo::RnullStr6::operator <(const algo::RnullStr6 &rhs) const {
12143 return algo::RnullStr6_Lt(const_cast<algo::RnullStr6&>(*this),const_cast<algo::RnullStr6&>(rhs));
12144}
12145
12146inline bool algo::RnullStr6::operator >(const algo::RnullStr6 &rhs) const {
12147 return rhs < *this;
12148}
12149
12150inline bool algo::RnullStr6::operator <=(const algo::RnullStr6 &rhs) const {
12151 return !(rhs < *this);
12152}
12153
12154inline bool algo::RnullStr6::operator >=(const algo::RnullStr6 &rhs) const {
12155 return !(*this < rhs);
12156}
12157inline algo::RnullStr6::RnullStr6() {
12158 algo::RnullStr6_Init(*this);
12159}
12160
12161
12162// --- algo.RnullStr6.ch.Getary
12163// Access string as array of chars
12164inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr6& parent) {
12165 int len = ch_N(parent);
12166 algo::aryptr<char> ret((char*)parent.ch, len);
12167 return ret;
12168}
12169
12170// --- algo.RnullStr6.ch.HashStrptr
12171inline u32 algo::RnullStr6_Hash(u32 prev, const algo::strptr &str) {
12172 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12173}
12174
12175// --- algo.RnullStr6.ch.Init
12176inline void algo::ch_Init(algo::RnullStr6 &parent) {
12177 memset(parent.ch, 0, 6);
12178}
12179
12180// --- algo.RnullStr6.ch.Max
12181// always return constant 6
12182inline int algo::ch_Max(algo::RnullStr6& parent) {
12183 (void)parent;
12184 return 6;
12185}
12186
12187// --- algo.RnullStr6.ch.N
12188inline int algo::ch_N(const algo::RnullStr6& parent) {
12189 u64 ret;
12190 ret = 6;
12191 while (ret>0 && parent.ch[ret-1]==u8(0)) {
12192 ret--;
12193 }
12194 return int(ret);
12195}
12196
12197// --- algo.RnullStr6.ch.AssignStrptr
12198// Copy from strptr (operator=)
12199inline void algo::RnullStr6::operator =(const algo::strptr &str) {
12200 ch_SetStrptr(*this, str);
12201}
12202
12203// --- algo.RnullStr6.ch.Set
12204// Copy from same type
12205// Copy value from RHS.
12206inline void algo::RnullStr6::operator =(const algo::RnullStr6& parent) {
12207 memcpy(ch, parent.ch, 6);
12208}
12209
12210// --- algo.RnullStr6.ch.Ctor
12211inline algo::RnullStr6::RnullStr6(const algo::RnullStr6 &rhs) {
12212 operator =(rhs);
12213}
12214
12215// --- algo.RnullStr6.ch.CtorStrptr
12216inline algo::RnullStr6::RnullStr6(const algo::strptr &rhs) {
12217 ch_SetStrptr(*this, rhs);
12218}
12219
12220// --- algo.RnullStr6.ch.Cast
12221inline algo::RnullStr6::operator algo::strptr () const {
12222 return ch_Getary(*this);
12223}
12224
12225// --- algo.RnullStr6..Lt
12226inline bool algo::RnullStr6_Lt(algo::RnullStr6 lhs, algo::RnullStr6 rhs) {
12227 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12228}
12229
12230// --- algo.RnullStr6..Cmp
12231inline i32 algo::RnullStr6_Cmp(algo::RnullStr6 lhs, algo::RnullStr6 rhs) {
12232 i32 retval = 0;
12233 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12234 return retval;
12235}
12236
12237// --- algo.RnullStr6..Init
12238// Set all fields to initial values.
12239inline void algo::RnullStr6_Init(algo::RnullStr6& parent) {
12240 memset(parent.ch, 0, 6);
12241}
12242
12243// --- algo.RnullStr6..Eq
12244inline bool algo::RnullStr6_Eq(algo::RnullStr6 lhs, algo::RnullStr6 rhs) {
12245 bool retval = true;
12246 retval = retval
12247 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
12248 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
12249 return retval;
12250}
12251
12252// --- algo.RnullStr6..Update
12253// Set value. Return true if new value is different from old value.
12254inline bool algo::RnullStr6_Update(algo::RnullStr6 &lhs, algo::RnullStr6 rhs) {
12255 bool ret = !RnullStr6_Eq(lhs, rhs); // compare values
12256 if (ret) {
12257 lhs = rhs; // update
12258 }
12259 return ret;
12260}
12261
12262// --- algo.RnullStr6..EqStrptr
12263inline bool algo::RnullStr6_EqStrptr(algo::RnullStr6 lhs, const algo::strptr& rhs) {
12264 return algo::strptr_Eq(ch_Getary(lhs), rhs);
12265}
12266
12267inline bool algo::RnullStr60::operator ==(const algo::RnullStr60 &rhs) const {
12268 return algo::RnullStr60_Eq(const_cast<algo::RnullStr60&>(*this),const_cast<algo::RnullStr60&>(rhs));
12269}
12270
12271inline bool algo::RnullStr60::operator !=(const algo::RnullStr60 &rhs) const {
12272 return !algo::RnullStr60_Eq(const_cast<algo::RnullStr60&>(*this),const_cast<algo::RnullStr60&>(rhs));
12273}
12274
12275inline bool algo::RnullStr60::operator ==(const algo::strptr &rhs) const {
12276 return algo::RnullStr60_EqStrptr(const_cast<algo::RnullStr60&>(*this),rhs);
12277}
12278
12279inline bool algo::RnullStr60::operator <(const algo::RnullStr60 &rhs) const {
12280 return algo::RnullStr60_Lt(const_cast<algo::RnullStr60&>(*this),const_cast<algo::RnullStr60&>(rhs));
12281}
12282
12283inline bool algo::RnullStr60::operator >(const algo::RnullStr60 &rhs) const {
12284 return rhs < *this;
12285}
12286
12287inline bool algo::RnullStr60::operator <=(const algo::RnullStr60 &rhs) const {
12288 return !(rhs < *this);
12289}
12290
12291inline bool algo::RnullStr60::operator >=(const algo::RnullStr60 &rhs) const {
12292 return !(*this < rhs);
12293}
12294inline algo::RnullStr60::RnullStr60() {
12295 algo::RnullStr60_Init(*this);
12296}
12297
12298
12299// --- algo.RnullStr60.ch.Getary
12300// Access string as array of chars
12301inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr60& parent) {
12302 int len = ch_N(parent);
12303 algo::aryptr<char> ret((char*)parent.ch, len);
12304 return ret;
12305}
12306
12307// --- algo.RnullStr60.ch.HashStrptr
12308inline u32 algo::RnullStr60_Hash(u32 prev, const algo::strptr &str) {
12309 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12310}
12311
12312// --- algo.RnullStr60.ch.Init
12313inline void algo::ch_Init(algo::RnullStr60 &parent) {
12314 memset(parent.ch, 0, 60);
12315}
12316
12317// --- algo.RnullStr60.ch.Max
12318// always return constant 60
12319inline int algo::ch_Max(algo::RnullStr60& parent) {
12320 (void)parent;
12321 return 60;
12322}
12323
12324// --- algo.RnullStr60.ch.N
12325inline int algo::ch_N(const algo::RnullStr60& parent) {
12326 u64 ret;
12327 ret = 60;
12328 while (ret>0 && parent.ch[ret-1]==u8(0)) {
12329 ret--;
12330 }
12331 return int(ret);
12332}
12333
12334// --- algo.RnullStr60.ch.AssignStrptr
12335// Copy from strptr (operator=)
12336inline void algo::RnullStr60::operator =(const algo::strptr &str) {
12337 ch_SetStrptr(*this, str);
12338}
12339
12340// --- algo.RnullStr60.ch.Set
12341// Copy from same type
12342// Copy value from RHS.
12343inline void algo::RnullStr60::operator =(const algo::RnullStr60& parent) {
12344 memcpy(ch, parent.ch, 60);
12345}
12346
12347// --- algo.RnullStr60.ch.Ctor
12348inline algo::RnullStr60::RnullStr60(const algo::RnullStr60 &rhs) {
12349 operator =(rhs);
12350}
12351
12352// --- algo.RnullStr60.ch.CtorStrptr
12353inline algo::RnullStr60::RnullStr60(const algo::strptr &rhs) {
12354 ch_SetStrptr(*this, rhs);
12355}
12356
12357// --- algo.RnullStr60.ch.Cast
12358inline algo::RnullStr60::operator algo::strptr () const {
12359 return ch_Getary(*this);
12360}
12361
12362// --- algo.RnullStr60..Lt
12363inline bool algo::RnullStr60_Lt(algo::RnullStr60& lhs, algo::RnullStr60& rhs) {
12364 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12365}
12366
12367// --- algo.RnullStr60..Cmp
12368inline i32 algo::RnullStr60_Cmp(algo::RnullStr60& lhs, algo::RnullStr60& rhs) {
12369 i32 retval = 0;
12370 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12371 return retval;
12372}
12373
12374// --- algo.RnullStr60..Init
12375// Set all fields to initial values.
12376inline void algo::RnullStr60_Init(algo::RnullStr60& parent) {
12377 memset(parent.ch, 0, 60);
12378}
12379
12380// --- algo.RnullStr60..Eq
12381inline bool algo::RnullStr60_Eq(algo::RnullStr60& lhs, algo::RnullStr60& rhs) {
12382 bool retval = true;
12383 retval = retval
12384 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
12385 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
12386 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
12387 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
12388 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
12389 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
12390 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
12391 &&*(u32*)(lhs.ch+56) == *(u32*)(rhs.ch+56);
12392 return retval;
12393}
12394
12395// --- algo.RnullStr60..Update
12396// Set value. Return true if new value is different from old value.
12397inline bool algo::RnullStr60_Update(algo::RnullStr60 &lhs, algo::RnullStr60& rhs) {
12398 bool ret = !RnullStr60_Eq(lhs, rhs); // compare values
12399 if (ret) {
12400 lhs = rhs; // update
12401 }
12402 return ret;
12403}
12404
12405// --- algo.RnullStr60..EqStrptr
12406inline bool algo::RnullStr60_EqStrptr(const algo::RnullStr60& lhs, const algo::strptr& rhs) {
12407 return algo::strptr_Eq(ch_Getary(lhs), rhs);
12408}
12409
12410inline bool algo::RnullStr62::operator ==(const algo::RnullStr62 &rhs) const {
12411 return algo::RnullStr62_Eq(const_cast<algo::RnullStr62&>(*this),const_cast<algo::RnullStr62&>(rhs));
12412}
12413
12414inline bool algo::RnullStr62::operator !=(const algo::RnullStr62 &rhs) const {
12415 return !algo::RnullStr62_Eq(const_cast<algo::RnullStr62&>(*this),const_cast<algo::RnullStr62&>(rhs));
12416}
12417
12418inline bool algo::RnullStr62::operator ==(const algo::strptr &rhs) const {
12419 return algo::RnullStr62_EqStrptr(const_cast<algo::RnullStr62&>(*this),rhs);
12420}
12421
12422inline bool algo::RnullStr62::operator <(const algo::RnullStr62 &rhs) const {
12423 return algo::RnullStr62_Lt(const_cast<algo::RnullStr62&>(*this),const_cast<algo::RnullStr62&>(rhs));
12424}
12425
12426inline bool algo::RnullStr62::operator >(const algo::RnullStr62 &rhs) const {
12427 return rhs < *this;
12428}
12429
12430inline bool algo::RnullStr62::operator <=(const algo::RnullStr62 &rhs) const {
12431 return !(rhs < *this);
12432}
12433
12434inline bool algo::RnullStr62::operator >=(const algo::RnullStr62 &rhs) const {
12435 return !(*this < rhs);
12436}
12437inline algo::RnullStr62::RnullStr62() {
12438 algo::RnullStr62_Init(*this);
12439}
12440
12441
12442// --- algo.RnullStr62.ch.Getary
12443// Access string as array of chars
12444inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr62& parent) {
12445 int len = ch_N(parent);
12446 algo::aryptr<char> ret((char*)parent.ch, len);
12447 return ret;
12448}
12449
12450// --- algo.RnullStr62.ch.HashStrptr
12451inline u32 algo::RnullStr62_Hash(u32 prev, const algo::strptr &str) {
12452 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12453}
12454
12455// --- algo.RnullStr62.ch.Init
12456inline void algo::ch_Init(algo::RnullStr62 &parent) {
12457 memset(parent.ch, 0, 62);
12458}
12459
12460// --- algo.RnullStr62.ch.Max
12461// always return constant 62
12462inline int algo::ch_Max(algo::RnullStr62& parent) {
12463 (void)parent;
12464 return 62;
12465}
12466
12467// --- algo.RnullStr62.ch.N
12468inline int algo::ch_N(const algo::RnullStr62& parent) {
12469 u64 ret;
12470 ret = 62;
12471 while (ret>0 && parent.ch[ret-1]==u8(0)) {
12472 ret--;
12473 }
12474 return int(ret);
12475}
12476
12477// --- algo.RnullStr62.ch.AssignStrptr
12478// Copy from strptr (operator=)
12479inline void algo::RnullStr62::operator =(const algo::strptr &str) {
12480 ch_SetStrptr(*this, str);
12481}
12482
12483// --- algo.RnullStr62.ch.Set
12484// Copy from same type
12485// Copy value from RHS.
12486inline void algo::RnullStr62::operator =(const algo::RnullStr62& parent) {
12487 memcpy(ch, parent.ch, 62);
12488}
12489
12490// --- algo.RnullStr62.ch.Ctor
12491inline algo::RnullStr62::RnullStr62(const algo::RnullStr62 &rhs) {
12492 operator =(rhs);
12493}
12494
12495// --- algo.RnullStr62.ch.CtorStrptr
12496inline algo::RnullStr62::RnullStr62(const algo::strptr &rhs) {
12497 ch_SetStrptr(*this, rhs);
12498}
12499
12500// --- algo.RnullStr62.ch.Cast
12501inline algo::RnullStr62::operator algo::strptr () const {
12502 return ch_Getary(*this);
12503}
12504
12505// --- algo.RnullStr62..Lt
12506inline bool algo::RnullStr62_Lt(algo::RnullStr62& lhs, algo::RnullStr62& rhs) {
12507 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12508}
12509
12510// --- algo.RnullStr62..Cmp
12511inline i32 algo::RnullStr62_Cmp(algo::RnullStr62& lhs, algo::RnullStr62& rhs) {
12512 i32 retval = 0;
12513 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12514 return retval;
12515}
12516
12517// --- algo.RnullStr62..Init
12518// Set all fields to initial values.
12519inline void algo::RnullStr62_Init(algo::RnullStr62& parent) {
12520 memset(parent.ch, 0, 62);
12521}
12522
12523// --- algo.RnullStr62..Eq
12524inline bool algo::RnullStr62_Eq(algo::RnullStr62& lhs, algo::RnullStr62& rhs) {
12525 bool retval = true;
12526 retval = retval
12527 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
12528 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
12529 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
12530 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
12531 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
12532 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
12533 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
12534 &&*(u32*)(lhs.ch+56) == *(u32*)(rhs.ch+56)
12535 &&*(u16*)(lhs.ch+60) == *(u16*)(rhs.ch+60);
12536 return retval;
12537}
12538
12539// --- algo.RnullStr62..Update
12540// Set value. Return true if new value is different from old value.
12541inline bool algo::RnullStr62_Update(algo::RnullStr62 &lhs, algo::RnullStr62& rhs) {
12542 bool ret = !RnullStr62_Eq(lhs, rhs); // compare values
12543 if (ret) {
12544 lhs = rhs; // update
12545 }
12546 return ret;
12547}
12548
12549// --- algo.RnullStr62..EqStrptr
12550inline bool algo::RnullStr62_EqStrptr(const algo::RnullStr62& lhs, const algo::strptr& rhs) {
12551 return algo::strptr_Eq(ch_Getary(lhs), rhs);
12552}
12553inline algo::RnullStr66::RnullStr66() {
12554 algo::RnullStr66_Init(*this);
12555}
12556
12557
12558// --- algo.RnullStr66.ch.Getary
12559// Access string as array of chars
12560inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr66& parent) {
12561 int len = ch_N(parent);
12562 algo::aryptr<char> ret((char*)parent.ch, len);
12563 return ret;
12564}
12565
12566// --- algo.RnullStr66.ch.HashStrptr
12567inline u32 algo::RnullStr66_Hash(u32 prev, const algo::strptr &str) {
12568 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12569}
12570
12571// --- algo.RnullStr66.ch.Init
12572inline void algo::ch_Init(algo::RnullStr66 &parent) {
12573 memset(parent.ch, 0, 66);
12574}
12575
12576// --- algo.RnullStr66.ch.Max
12577// always return constant 66
12578inline int algo::ch_Max(algo::RnullStr66& parent) {
12579 (void)parent;
12580 return 66;
12581}
12582
12583// --- algo.RnullStr66.ch.N
12584inline int algo::ch_N(const algo::RnullStr66& parent) {
12585 u64 ret;
12586 ret = 66;
12587 while (ret>0 && parent.ch[ret-1]==u8(0)) {
12588 ret--;
12589 }
12590 return int(ret);
12591}
12592
12593// --- algo.RnullStr66.ch.AssignStrptr
12594// Copy from strptr (operator=)
12595inline void algo::RnullStr66::operator =(const algo::strptr &str) {
12596 ch_SetStrptr(*this, str);
12597}
12598
12599// --- algo.RnullStr66.ch.Set
12600// Copy from same type
12601// Copy value from RHS.
12602inline void algo::RnullStr66::operator =(const algo::RnullStr66& parent) {
12603 memcpy(ch, parent.ch, 66);
12604}
12605
12606// --- algo.RnullStr66.ch.Ctor
12607inline algo::RnullStr66::RnullStr66(const algo::RnullStr66 &rhs) {
12608 operator =(rhs);
12609}
12610
12611// --- algo.RnullStr66.ch.CtorStrptr
12612inline algo::RnullStr66::RnullStr66(const algo::strptr &rhs) {
12613 ch_SetStrptr(*this, rhs);
12614}
12615
12616// --- algo.RnullStr66.ch.Cast
12617inline algo::RnullStr66::operator algo::strptr () const {
12618 return ch_Getary(*this);
12619}
12620
12621// --- algo.RnullStr66..Lt
12622inline bool algo::RnullStr66_Lt(algo::RnullStr66& lhs, algo::RnullStr66& rhs) {
12623 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12624}
12625
12626// --- algo.RnullStr66..Cmp
12627inline i32 algo::RnullStr66_Cmp(algo::RnullStr66& lhs, algo::RnullStr66& rhs) {
12628 i32 retval = 0;
12629 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12630 return retval;
12631}
12632
12633// --- algo.RnullStr66..Init
12634// Set all fields to initial values.
12635inline void algo::RnullStr66_Init(algo::RnullStr66& parent) {
12636 memset(parent.ch, 0, 66);
12637}
12638
12639// --- algo.RnullStr66..Eq
12640inline bool algo::RnullStr66_Eq(algo::RnullStr66& lhs, algo::RnullStr66& rhs) {
12641 bool retval = true;
12642 retval = retval
12643 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
12644 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
12645 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
12646 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
12647 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
12648 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
12649 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
12650 &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
12651 &&*(u16*)(lhs.ch+64) == *(u16*)(rhs.ch+64);
12652 return retval;
12653}
12654
12655// --- algo.RnullStr66..Update
12656// Set value. Return true if new value is different from old value.
12657inline bool algo::RnullStr66_Update(algo::RnullStr66 &lhs, algo::RnullStr66& rhs) {
12658 bool ret = !RnullStr66_Eq(lhs, rhs); // compare values
12659 if (ret) {
12660 lhs = rhs; // update
12661 }
12662 return ret;
12663}
12664
12665// --- algo.RnullStr66..EqStrptr
12666inline bool algo::RnullStr66_EqStrptr(const algo::RnullStr66& lhs, const algo::strptr& rhs) {
12667 return algo::strptr_Eq(ch_Getary(lhs), rhs);
12668}
12669
12670inline bool algo::RnullStr6_U32::operator ==(const algo::RnullStr6_U32 &rhs) const {
12671 return algo::RnullStr6_U32_Eq(const_cast<algo::RnullStr6_U32&>(*this),const_cast<algo::RnullStr6_U32&>(rhs));
12672}
12673
12674inline bool algo::RnullStr6_U32::operator !=(const algo::RnullStr6_U32 &rhs) const {
12675 return !algo::RnullStr6_U32_Eq(const_cast<algo::RnullStr6_U32&>(*this),const_cast<algo::RnullStr6_U32&>(rhs));
12676}
12677
12678inline bool algo::RnullStr6_U32::operator ==(const algo::strptr &rhs) const {
12679 return algo::RnullStr6_U32_EqStrptr(const_cast<algo::RnullStr6_U32&>(*this),rhs);
12680}
12681inline algo::RnullStr6_U32::RnullStr6_U32() {
12682 algo::RnullStr6_U32_Init(*this);
12683}
12684
12685
12686// --- algo.RnullStr6_U32.ch.Getary
12687// Access string as array of chars
12688inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr6_U32& parent) {
12689 int len = ch_N(parent);
12690 algo::aryptr<char> ret((char*)parent.ch, len);
12691 return ret;
12692}
12693
12694// --- algo.RnullStr6_U32.ch.HashStrptr
12695inline u32 algo::RnullStr6_U32_Hash(u32 prev, const algo::strptr &str) {
12696 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12697}
12698
12699// --- algo.RnullStr6_U32.ch.Init
12700inline void algo::ch_Init(algo::RnullStr6_U32 &parent) {
12701 memset(parent.ch, 0, 6);
12702}
12703
12704// --- algo.RnullStr6_U32.ch.Max
12705// always return constant 6
12706inline int algo::ch_Max(algo::RnullStr6_U32& parent) {
12707 (void)parent;
12708 return 6;
12709}
12710
12711// --- algo.RnullStr6_U32.ch.N
12712inline int algo::ch_N(const algo::RnullStr6_U32& parent) {
12713 u64 ret;
12714 ret = 6;
12715 while (ret>0 && parent.ch[ret-1]==u8(0)) {
12716 ret--;
12717 }
12718 return int(ret);
12719}
12720
12721// --- algo.RnullStr6_U32.ch.AssignStrptr
12722// Copy from strptr (operator=)
12723inline void algo::RnullStr6_U32::operator =(const algo::strptr &str) {
12724 ch_SetStrptr(*this, str);
12725}
12726
12727// --- algo.RnullStr6_U32.ch.Set
12728// Copy from same type
12729// Copy value from RHS.
12730inline void algo::RnullStr6_U32::operator =(const algo::RnullStr6_U32& parent) {
12731 memcpy(ch, parent.ch, 6);
12732}
12733
12734// --- algo.RnullStr6_U32.ch.Ctor
12735inline algo::RnullStr6_U32::RnullStr6_U32(const algo::RnullStr6_U32 &rhs) {
12736 operator =(rhs);
12737}
12738
12739// --- algo.RnullStr6_U32.ch.CtorStrptr
12740inline algo::RnullStr6_U32::RnullStr6_U32(const algo::strptr &rhs) {
12741 ch_SetStrptr(*this, rhs);
12742}
12743
12744// --- algo.RnullStr6_U32.ch.Cast
12745inline algo::RnullStr6_U32::operator algo::strptr () const {
12746 return ch_Getary(*this);
12747}
12748
12749// --- algo.RnullStr6_U32..Cmp
12750inline i32 algo::RnullStr6_U32_Cmp(algo::RnullStr6_U32& lhs, algo::RnullStr6_U32& rhs) {
12751 i32 retval = 0;
12752 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12753 return retval;
12754}
12755
12756// --- algo.RnullStr6_U32..Init
12757// Set all fields to initial values.
12758inline void algo::RnullStr6_U32_Init(algo::RnullStr6_U32& parent) {
12759 memset(parent.ch, 0, 6);
12760}
12761
12762// --- algo.RnullStr6_U32..Eq
12763inline bool algo::RnullStr6_U32_Eq(algo::RnullStr6_U32& lhs, algo::RnullStr6_U32& rhs) {
12764 bool retval = true;
12765 retval = retval
12766 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
12767 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
12768 return retval;
12769}
12770
12771// --- algo.RnullStr6_U32..EqStrptr
12772inline bool algo::RnullStr6_U32_EqStrptr(const algo::RnullStr6_U32& lhs, const algo::strptr& rhs) {
12773 return algo::strptr_Eq(ch_Getary(lhs), rhs);
12774}
12775
12776inline bool algo::RnullStr7::operator ==(const algo::RnullStr7 &rhs) const {
12777 return algo::RnullStr7_Eq(const_cast<algo::RnullStr7&>(*this),const_cast<algo::RnullStr7&>(rhs));
12778}
12779
12780inline bool algo::RnullStr7::operator !=(const algo::RnullStr7 &rhs) const {
12781 return !algo::RnullStr7_Eq(const_cast<algo::RnullStr7&>(*this),const_cast<algo::RnullStr7&>(rhs));
12782}
12783
12784inline bool algo::RnullStr7::operator ==(const algo::strptr &rhs) const {
12785 return algo::RnullStr7_EqStrptr(const_cast<algo::RnullStr7&>(*this),rhs);
12786}
12787
12788inline bool algo::RnullStr7::operator <(const algo::RnullStr7 &rhs) const {
12789 return algo::RnullStr7_Lt(const_cast<algo::RnullStr7&>(*this),const_cast<algo::RnullStr7&>(rhs));
12790}
12791
12792inline bool algo::RnullStr7::operator >(const algo::RnullStr7 &rhs) const {
12793 return rhs < *this;
12794}
12795
12796inline bool algo::RnullStr7::operator <=(const algo::RnullStr7 &rhs) const {
12797 return !(rhs < *this);
12798}
12799
12800inline bool algo::RnullStr7::operator >=(const algo::RnullStr7 &rhs) const {
12801 return !(*this < rhs);
12802}
12803inline algo::RnullStr7::RnullStr7() {
12804 algo::RnullStr7_Init(*this);
12805}
12806
12807
12808// --- algo.RnullStr7.ch.Getary
12809// Access string as array of chars
12810inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr7& parent) {
12811 int len = ch_N(parent);
12812 algo::aryptr<char> ret((char*)parent.ch, len);
12813 return ret;
12814}
12815
12816// --- algo.RnullStr7.ch.HashStrptr
12817inline u32 algo::RnullStr7_Hash(u32 prev, const algo::strptr &str) {
12818 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12819}
12820
12821// --- algo.RnullStr7.ch.Init
12822inline void algo::ch_Init(algo::RnullStr7 &parent) {
12823 memset(parent.ch, 0, 7);
12824}
12825
12826// --- algo.RnullStr7.ch.Max
12827// always return constant 7
12828inline int algo::ch_Max(algo::RnullStr7& parent) {
12829 (void)parent;
12830 return 7;
12831}
12832
12833// --- algo.RnullStr7.ch.N
12834inline int algo::ch_N(const algo::RnullStr7& parent) {
12835 u64 ret;
12836 ret = 7;
12837 while (ret>0 && parent.ch[ret-1]==u8(0)) {
12838 ret--;
12839 }
12840 return int(ret);
12841}
12842
12843// --- algo.RnullStr7.ch.AssignStrptr
12844// Copy from strptr (operator=)
12845inline void algo::RnullStr7::operator =(const algo::strptr &str) {
12846 ch_SetStrptr(*this, str);
12847}
12848
12849// --- algo.RnullStr7.ch.Set
12850// Copy from same type
12851// Copy value from RHS.
12852inline void algo::RnullStr7::operator =(const algo::RnullStr7& parent) {
12853 memcpy(ch, parent.ch, 7);
12854}
12855
12856// --- algo.RnullStr7.ch.Ctor
12857inline algo::RnullStr7::RnullStr7(const algo::RnullStr7 &rhs) {
12858 operator =(rhs);
12859}
12860
12861// --- algo.RnullStr7.ch.CtorStrptr
12862inline algo::RnullStr7::RnullStr7(const algo::strptr &rhs) {
12863 ch_SetStrptr(*this, rhs);
12864}
12865
12866// --- algo.RnullStr7.ch.Cast
12867inline algo::RnullStr7::operator algo::strptr () const {
12868 return ch_Getary(*this);
12869}
12870
12871// --- algo.RnullStr7..Lt
12872inline bool algo::RnullStr7_Lt(algo::RnullStr7 lhs, algo::RnullStr7 rhs) {
12873 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12874}
12875
12876// --- algo.RnullStr7..Cmp
12877inline i32 algo::RnullStr7_Cmp(algo::RnullStr7 lhs, algo::RnullStr7 rhs) {
12878 i32 retval = 0;
12879 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12880 return retval;
12881}
12882
12883// --- algo.RnullStr7..Init
12884// Set all fields to initial values.
12885inline void algo::RnullStr7_Init(algo::RnullStr7& parent) {
12886 memset(parent.ch, 0, 7);
12887}
12888
12889// --- algo.RnullStr7..Eq
12890inline bool algo::RnullStr7_Eq(algo::RnullStr7 lhs, algo::RnullStr7 rhs) {
12891 bool retval = true;
12892 retval = retval
12893 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
12894 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
12895 &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
12896 return retval;
12897}
12898
12899// --- algo.RnullStr7..Update
12900// Set value. Return true if new value is different from old value.
12901inline bool algo::RnullStr7_Update(algo::RnullStr7 &lhs, algo::RnullStr7 rhs) {
12902 bool ret = !RnullStr7_Eq(lhs, rhs); // compare values
12903 if (ret) {
12904 lhs = rhs; // update
12905 }
12906 return ret;
12907}
12908
12909// --- algo.RnullStr7..EqStrptr
12910inline bool algo::RnullStr7_EqStrptr(algo::RnullStr7 lhs, const algo::strptr& rhs) {
12911 return algo::strptr_Eq(ch_Getary(lhs), rhs);
12912}
12913inline algo::RnullStr8::RnullStr8() {
12914 algo::RnullStr8_Init(*this);
12915}
12916
12917
12918// --- algo.RnullStr8.ch.Getary
12919// Access string as array of chars
12920inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr8& parent) {
12921 int len = ch_N(parent);
12922 algo::aryptr<char> ret((char*)parent.ch, len);
12923 return ret;
12924}
12925
12926// --- algo.RnullStr8.ch.HashStrptr
12927inline u32 algo::RnullStr8_Hash(u32 prev, const algo::strptr &str) {
12928 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
12929}
12930
12931// --- algo.RnullStr8.ch.Init
12932inline void algo::ch_Init(algo::RnullStr8 &parent) {
12933 memset(parent.ch, 0, 8);
12934}
12935
12936// --- algo.RnullStr8.ch.Max
12937// always return constant 8
12938inline int algo::ch_Max(algo::RnullStr8& parent) {
12939 (void)parent;
12940 return 8;
12941}
12942
12943// --- algo.RnullStr8.ch.N
12944inline int algo::ch_N(const algo::RnullStr8& parent) {
12945 u64 ret;
12946 ret = 8;
12947 while (ret>0 && parent.ch[ret-1]==u8(0)) {
12948 ret--;
12949 }
12950 return int(ret);
12951}
12952
12953// --- algo.RnullStr8.ch.AssignStrptr
12954// Copy from strptr (operator=)
12955inline void algo::RnullStr8::operator =(const algo::strptr &str) {
12956 ch_SetStrptr(*this, str);
12957}
12958
12959// --- algo.RnullStr8.ch.Set
12960// Copy from same type
12961// Copy value from RHS.
12962inline void algo::RnullStr8::operator =(const algo::RnullStr8& parent) {
12963 memcpy(ch, parent.ch, 8);
12964}
12965
12966// --- algo.RnullStr8.ch.Ctor
12967inline algo::RnullStr8::RnullStr8(const algo::RnullStr8 &rhs) {
12968 operator =(rhs);
12969}
12970
12971// --- algo.RnullStr8.ch.CtorStrptr
12972inline algo::RnullStr8::RnullStr8(const algo::strptr &rhs) {
12973 ch_SetStrptr(*this, rhs);
12974}
12975
12976// --- algo.RnullStr8.ch.Cast
12977inline algo::RnullStr8::operator algo::strptr () const {
12978 return ch_Getary(*this);
12979}
12980
12981// --- algo.RnullStr8..Lt
12982inline bool algo::RnullStr8_Lt(algo::RnullStr8 lhs, algo::RnullStr8 rhs) {
12983 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
12984}
12985
12986// --- algo.RnullStr8..Cmp
12987inline i32 algo::RnullStr8_Cmp(algo::RnullStr8 lhs, algo::RnullStr8 rhs) {
12988 i32 retval = 0;
12989 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
12990 return retval;
12991}
12992
12993// --- algo.RnullStr8..Init
12994// Set all fields to initial values.
12995inline void algo::RnullStr8_Init(algo::RnullStr8& parent) {
12996 memset(parent.ch, 0, 8);
12997}
12998
12999// --- algo.RnullStr8..Eq
13000inline bool algo::RnullStr8_Eq(algo::RnullStr8 lhs, algo::RnullStr8 rhs) {
13001 bool retval = true;
13002 retval = retval
13003 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
13004 return retval;
13005}
13006
13007// --- algo.RnullStr8..Update
13008// Set value. Return true if new value is different from old value.
13009inline bool algo::RnullStr8_Update(algo::RnullStr8 &lhs, algo::RnullStr8 rhs) {
13010 bool ret = !RnullStr8_Eq(lhs, rhs); // compare values
13011 if (ret) {
13012 lhs = rhs; // update
13013 }
13014 return ret;
13015}
13016
13017// --- algo.RnullStr8..EqStrptr
13018inline bool algo::RnullStr8_EqStrptr(algo::RnullStr8 lhs, const algo::strptr& rhs) {
13019 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13020}
13021inline algo::RnullStr80::RnullStr80() {
13022 algo::RnullStr80_Init(*this);
13023}
13024
13025
13026// --- algo.RnullStr80.ch.Getary
13027// Access string as array of chars
13028inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr80& parent) {
13029 int len = ch_N(parent);
13030 algo::aryptr<char> ret((char*)parent.ch, len);
13031 return ret;
13032}
13033
13034// --- algo.RnullStr80.ch.HashStrptr
13035inline u32 algo::RnullStr80_Hash(u32 prev, const algo::strptr &str) {
13036 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13037}
13038
13039// --- algo.RnullStr80.ch.Init
13040inline void algo::ch_Init(algo::RnullStr80 &parent) {
13041 memset(parent.ch, 0, 80);
13042}
13043
13044// --- algo.RnullStr80.ch.Max
13045// always return constant 80
13046inline int algo::ch_Max(algo::RnullStr80& parent) {
13047 (void)parent;
13048 return 80;
13049}
13050
13051// --- algo.RnullStr80.ch.N
13052inline int algo::ch_N(const algo::RnullStr80& parent) {
13053 u64 ret;
13054 ret = 80;
13055 while (ret>0 && parent.ch[ret-1]==u8(0)) {
13056 ret--;
13057 }
13058 return int(ret);
13059}
13060
13061// --- algo.RnullStr80.ch.AssignStrptr
13062// Copy from strptr (operator=)
13063inline void algo::RnullStr80::operator =(const algo::strptr &str) {
13064 ch_SetStrptr(*this, str);
13065}
13066
13067// --- algo.RnullStr80.ch.Set
13068// Copy from same type
13069// Copy value from RHS.
13070inline void algo::RnullStr80::operator =(const algo::RnullStr80& parent) {
13071 memcpy(ch, parent.ch, 80);
13072}
13073
13074// --- algo.RnullStr80.ch.Ctor
13075inline algo::RnullStr80::RnullStr80(const algo::RnullStr80 &rhs) {
13076 operator =(rhs);
13077}
13078
13079// --- algo.RnullStr80.ch.CtorStrptr
13080inline algo::RnullStr80::RnullStr80(const algo::strptr &rhs) {
13081 ch_SetStrptr(*this, rhs);
13082}
13083
13084// --- algo.RnullStr80.ch.Cast
13085inline algo::RnullStr80::operator algo::strptr () const {
13086 return ch_Getary(*this);
13087}
13088
13089// --- algo.RnullStr80..Lt
13090inline bool algo::RnullStr80_Lt(algo::RnullStr80& lhs, algo::RnullStr80& rhs) {
13091 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
13092}
13093
13094// --- algo.RnullStr80..Cmp
13095inline i32 algo::RnullStr80_Cmp(algo::RnullStr80& lhs, algo::RnullStr80& rhs) {
13096 i32 retval = 0;
13097 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13098 return retval;
13099}
13100
13101// --- algo.RnullStr80..Init
13102// Set all fields to initial values.
13103inline void algo::RnullStr80_Init(algo::RnullStr80& parent) {
13104 memset(parent.ch, 0, 80);
13105}
13106
13107// --- algo.RnullStr80..Eq
13108inline bool algo::RnullStr80_Eq(algo::RnullStr80& lhs, algo::RnullStr80& rhs) {
13109 bool retval = true;
13110 retval = retval
13111 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13112 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
13113 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
13114 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
13115 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
13116 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
13117 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
13118 &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
13119 &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
13120 &&*(u64*)(lhs.ch+72) == *(u64*)(rhs.ch+72);
13121 return retval;
13122}
13123
13124// --- algo.RnullStr80..Update
13125// Set value. Return true if new value is different from old value.
13126inline bool algo::RnullStr80_Update(algo::RnullStr80 &lhs, algo::RnullStr80& rhs) {
13127 bool ret = !RnullStr80_Eq(lhs, rhs); // compare values
13128 if (ret) {
13129 lhs = rhs; // update
13130 }
13131 return ret;
13132}
13133
13134// --- algo.RnullStr80..EqStrptr
13135inline bool algo::RnullStr80_EqStrptr(const algo::RnullStr80& lhs, const algo::strptr& rhs) {
13136 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13137}
13138
13139inline bool algo::RnullStr9::operator ==(const algo::RnullStr9 &rhs) const {
13140 return algo::RnullStr9_Eq(const_cast<algo::RnullStr9&>(*this),const_cast<algo::RnullStr9&>(rhs));
13141}
13142
13143inline bool algo::RnullStr9::operator !=(const algo::RnullStr9 &rhs) const {
13144 return !algo::RnullStr9_Eq(const_cast<algo::RnullStr9&>(*this),const_cast<algo::RnullStr9&>(rhs));
13145}
13146
13147inline bool algo::RnullStr9::operator ==(const algo::strptr &rhs) const {
13148 return algo::RnullStr9_EqStrptr(const_cast<algo::RnullStr9&>(*this),rhs);
13149}
13150
13151inline bool algo::RnullStr9::operator <(const algo::RnullStr9 &rhs) const {
13152 return algo::RnullStr9_Lt(const_cast<algo::RnullStr9&>(*this),const_cast<algo::RnullStr9&>(rhs));
13153}
13154
13155inline bool algo::RnullStr9::operator >(const algo::RnullStr9 &rhs) const {
13156 return rhs < *this;
13157}
13158
13159inline bool algo::RnullStr9::operator <=(const algo::RnullStr9 &rhs) const {
13160 return !(rhs < *this);
13161}
13162
13163inline bool algo::RnullStr9::operator >=(const algo::RnullStr9 &rhs) const {
13164 return !(*this < rhs);
13165}
13166inline algo::RnullStr9::RnullStr9() {
13167 algo::RnullStr9_Init(*this);
13168}
13169
13170
13171// --- algo.RnullStr9.ch.Getary
13172// Access string as array of chars
13173inline algo::aryptr<char> algo::ch_Getary(const algo::RnullStr9& parent) {
13174 int len = ch_N(parent);
13175 algo::aryptr<char> ret((char*)parent.ch, len);
13176 return ret;
13177}
13178
13179// --- algo.RnullStr9.ch.HashStrptr
13180inline u32 algo::RnullStr9_Hash(u32 prev, const algo::strptr &str) {
13181 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13182}
13183
13184// --- algo.RnullStr9.ch.Init
13185inline void algo::ch_Init(algo::RnullStr9 &parent) {
13186 memset(parent.ch, 0, 9);
13187}
13188
13189// --- algo.RnullStr9.ch.Max
13190// always return constant 9
13191inline int algo::ch_Max(algo::RnullStr9& parent) {
13192 (void)parent;
13193 return 9;
13194}
13195
13196// --- algo.RnullStr9.ch.N
13197inline int algo::ch_N(const algo::RnullStr9& parent) {
13198 u64 ret;
13199 ret = 9;
13200 while (ret>0 && parent.ch[ret-1]==u8(0)) {
13201 ret--;
13202 }
13203 return int(ret);
13204}
13205
13206// --- algo.RnullStr9.ch.AssignStrptr
13207// Copy from strptr (operator=)
13208inline void algo::RnullStr9::operator =(const algo::strptr &str) {
13209 ch_SetStrptr(*this, str);
13210}
13211
13212// --- algo.RnullStr9.ch.Set
13213// Copy from same type
13214// Copy value from RHS.
13215inline void algo::RnullStr9::operator =(const algo::RnullStr9& parent) {
13216 memcpy(ch, parent.ch, 9);
13217}
13218
13219// --- algo.RnullStr9.ch.Ctor
13220inline algo::RnullStr9::RnullStr9(const algo::RnullStr9 &rhs) {
13221 operator =(rhs);
13222}
13223
13224// --- algo.RnullStr9.ch.CtorStrptr
13225inline algo::RnullStr9::RnullStr9(const algo::strptr &rhs) {
13226 ch_SetStrptr(*this, rhs);
13227}
13228
13229// --- algo.RnullStr9.ch.Cast
13230inline algo::RnullStr9::operator algo::strptr () const {
13231 return ch_Getary(*this);
13232}
13233
13234// --- algo.RnullStr9..Lt
13235inline bool algo::RnullStr9_Lt(algo::RnullStr9& lhs, algo::RnullStr9& rhs) {
13236 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
13237}
13238
13239// --- algo.RnullStr9..Cmp
13240inline i32 algo::RnullStr9_Cmp(algo::RnullStr9& lhs, algo::RnullStr9& rhs) {
13241 i32 retval = 0;
13242 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13243 return retval;
13244}
13245
13246// --- algo.RnullStr9..Init
13247// Set all fields to initial values.
13248inline void algo::RnullStr9_Init(algo::RnullStr9& parent) {
13249 memset(parent.ch, 0, 9);
13250}
13251
13252// --- algo.RnullStr9..Eq
13253inline bool algo::RnullStr9_Eq(algo::RnullStr9& lhs, algo::RnullStr9& rhs) {
13254 bool retval = true;
13255 retval = retval
13256 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13257 &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
13258 return retval;
13259}
13260
13261// --- algo.RnullStr9..Update
13262// Set value. Return true if new value is different from old value.
13263inline bool algo::RnullStr9_Update(algo::RnullStr9 &lhs, algo::RnullStr9& rhs) {
13264 bool ret = !RnullStr9_Eq(lhs, rhs); // compare values
13265 if (ret) {
13266 lhs = rhs; // update
13267 }
13268 return ret;
13269}
13270
13271// --- algo.RnullStr9..EqStrptr
13272inline bool algo::RnullStr9_EqStrptr(const algo::RnullStr9& lhs, const algo::strptr& rhs) {
13273 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13274}
13275
13276inline bool algo::RspaceStr10::operator ==(const algo::RspaceStr10 &rhs) const {
13277 return algo::RspaceStr10_Eq(const_cast<algo::RspaceStr10&>(*this),const_cast<algo::RspaceStr10&>(rhs));
13278}
13279
13280inline bool algo::RspaceStr10::operator !=(const algo::RspaceStr10 &rhs) const {
13281 return !algo::RspaceStr10_Eq(const_cast<algo::RspaceStr10&>(*this),const_cast<algo::RspaceStr10&>(rhs));
13282}
13283
13284inline bool algo::RspaceStr10::operator ==(const algo::strptr &rhs) const {
13285 return algo::RspaceStr10_EqStrptr(const_cast<algo::RspaceStr10&>(*this),rhs);
13286}
13287inline algo::RspaceStr10::RspaceStr10() {
13288 algo::RspaceStr10_Init(*this);
13289}
13290
13291
13292// --- algo.RspaceStr10.ch.Getary
13293// Access string as array of chars
13294inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr10& parent) {
13295 int len = ch_N(parent);
13296 algo::aryptr<char> ret((char*)parent.ch, len);
13297 return ret;
13298}
13299
13300// --- algo.RspaceStr10.ch.HashStrptr
13301inline u32 algo::RspaceStr10_Hash(u32 prev, const algo::strptr &str) {
13302 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13303}
13304
13305// --- algo.RspaceStr10.ch.Init
13306inline void algo::ch_Init(algo::RspaceStr10 &parent) {
13307 memset(parent.ch, ' ', 10);
13308}
13309
13310// --- algo.RspaceStr10.ch.Max
13311// always return constant 10
13312inline int algo::ch_Max(algo::RspaceStr10& parent) {
13313 (void)parent;
13314 return 10;
13315}
13316
13317// --- algo.RspaceStr10.ch.N
13318inline int algo::ch_N(const algo::RspaceStr10& parent) {
13319 u64 ret;
13320 ret = 10;
13321 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13322 ret--;
13323 }
13324 return int(ret);
13325}
13326
13327// --- algo.RspaceStr10.ch.AssignStrptr
13328// Copy from strptr (operator=)
13329inline void algo::RspaceStr10::operator =(const algo::strptr &str) {
13330 ch_SetStrptr(*this, str);
13331}
13332
13333// --- algo.RspaceStr10.ch.Set
13334// Copy from same type
13335// Copy value from RHS.
13336inline void algo::RspaceStr10::operator =(const algo::RspaceStr10& parent) {
13337 memcpy(ch, parent.ch, 10);
13338}
13339
13340// --- algo.RspaceStr10.ch.Ctor
13341inline algo::RspaceStr10::RspaceStr10(const algo::RspaceStr10 &rhs) {
13342 operator =(rhs);
13343}
13344
13345// --- algo.RspaceStr10.ch.CtorStrptr
13346inline algo::RspaceStr10::RspaceStr10(const algo::strptr &rhs) {
13347 ch_SetStrptr(*this, rhs);
13348}
13349
13350// --- algo.RspaceStr10.ch.Cast
13351inline algo::RspaceStr10::operator algo::strptr () const {
13352 return ch_Getary(*this);
13353}
13354
13355// --- algo.RspaceStr10..Cmp
13356inline i32 algo::RspaceStr10_Cmp(algo::RspaceStr10 lhs, algo::RspaceStr10 rhs) {
13357 i32 retval = 0;
13358 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13359 return retval;
13360}
13361
13362// --- algo.RspaceStr10..Init
13363// Set all fields to initial values.
13364inline void algo::RspaceStr10_Init(algo::RspaceStr10& parent) {
13365 memset(parent.ch, ' ', 10);
13366}
13367
13368// --- algo.RspaceStr10..Eq
13369inline bool algo::RspaceStr10_Eq(algo::RspaceStr10 lhs, algo::RspaceStr10 rhs) {
13370 bool retval = true;
13371 retval = retval
13372 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13373 &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8);
13374 return retval;
13375}
13376
13377// --- algo.RspaceStr10..EqStrptr
13378inline bool algo::RspaceStr10_EqStrptr(algo::RspaceStr10 lhs, const algo::strptr& rhs) {
13379 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13380}
13381
13382inline bool algo::RspaceStr100::operator ==(const algo::RspaceStr100 &rhs) const {
13383 return algo::RspaceStr100_Eq(const_cast<algo::RspaceStr100&>(*this),const_cast<algo::RspaceStr100&>(rhs));
13384}
13385
13386inline bool algo::RspaceStr100::operator !=(const algo::RspaceStr100 &rhs) const {
13387 return !algo::RspaceStr100_Eq(const_cast<algo::RspaceStr100&>(*this),const_cast<algo::RspaceStr100&>(rhs));
13388}
13389
13390inline bool algo::RspaceStr100::operator ==(const algo::strptr &rhs) const {
13391 return algo::RspaceStr100_EqStrptr(const_cast<algo::RspaceStr100&>(*this),rhs);
13392}
13393inline algo::RspaceStr100::RspaceStr100() {
13394 algo::RspaceStr100_Init(*this);
13395}
13396
13397
13398// --- algo.RspaceStr100.ch.Getary
13399// Access string as array of chars
13400inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr100& parent) {
13401 int len = ch_N(parent);
13402 algo::aryptr<char> ret((char*)parent.ch, len);
13403 return ret;
13404}
13405
13406// --- algo.RspaceStr100.ch.HashStrptr
13407inline u32 algo::RspaceStr100_Hash(u32 prev, const algo::strptr &str) {
13408 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13409}
13410
13411// --- algo.RspaceStr100.ch.Init
13412inline void algo::ch_Init(algo::RspaceStr100 &parent) {
13413 memset(parent.ch, ' ', 100);
13414}
13415
13416// --- algo.RspaceStr100.ch.Max
13417// always return constant 100
13418inline int algo::ch_Max(algo::RspaceStr100& parent) {
13419 (void)parent;
13420 return 100;
13421}
13422
13423// --- algo.RspaceStr100.ch.N
13424inline int algo::ch_N(const algo::RspaceStr100& parent) {
13425 u64 ret;
13426 ret = 100;
13427 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13428 ret--;
13429 }
13430 return int(ret);
13431}
13432
13433// --- algo.RspaceStr100.ch.AssignStrptr
13434// Copy from strptr (operator=)
13435inline void algo::RspaceStr100::operator =(const algo::strptr &str) {
13436 ch_SetStrptr(*this, str);
13437}
13438
13439// --- algo.RspaceStr100.ch.Set
13440// Copy from same type
13441// Copy value from RHS.
13442inline void algo::RspaceStr100::operator =(const algo::RspaceStr100& parent) {
13443 memcpy(ch, parent.ch, 100);
13444}
13445
13446// --- algo.RspaceStr100.ch.Ctor
13447inline algo::RspaceStr100::RspaceStr100(const algo::RspaceStr100 &rhs) {
13448 operator =(rhs);
13449}
13450
13451// --- algo.RspaceStr100.ch.CtorStrptr
13452inline algo::RspaceStr100::RspaceStr100(const algo::strptr &rhs) {
13453 ch_SetStrptr(*this, rhs);
13454}
13455
13456// --- algo.RspaceStr100.ch.Cast
13457inline algo::RspaceStr100::operator algo::strptr () const {
13458 return ch_Getary(*this);
13459}
13460
13461// --- algo.RspaceStr100..Cmp
13462inline i32 algo::RspaceStr100_Cmp(algo::RspaceStr100& lhs, algo::RspaceStr100& rhs) {
13463 i32 retval = 0;
13464 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13465 return retval;
13466}
13467
13468// --- algo.RspaceStr100..Init
13469// Set all fields to initial values.
13470inline void algo::RspaceStr100_Init(algo::RspaceStr100& parent) {
13471 memset(parent.ch, ' ', 100);
13472}
13473
13474// --- algo.RspaceStr100..Eq
13475inline bool algo::RspaceStr100_Eq(algo::RspaceStr100& lhs, algo::RspaceStr100& rhs) {
13476 bool retval = true;
13477 retval = retval
13478 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13479 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
13480 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
13481 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
13482 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
13483 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
13484 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
13485 &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
13486 &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
13487 &&*(u64*)(lhs.ch+72) == *(u64*)(rhs.ch+72)
13488 &&*(u64*)(lhs.ch+80) == *(u64*)(rhs.ch+80)
13489 &&*(u64*)(lhs.ch+88) == *(u64*)(rhs.ch+88)
13490 &&*(u32*)(lhs.ch+96) == *(u32*)(rhs.ch+96);
13491 return retval;
13492}
13493
13494// --- algo.RspaceStr100..EqStrptr
13495inline bool algo::RspaceStr100_EqStrptr(const algo::RspaceStr100& lhs, const algo::strptr& rhs) {
13496 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13497}
13498
13499inline bool algo::RspaceStr11::operator ==(const algo::RspaceStr11 &rhs) const {
13500 return algo::RspaceStr11_Eq(const_cast<algo::RspaceStr11&>(*this),const_cast<algo::RspaceStr11&>(rhs));
13501}
13502
13503inline bool algo::RspaceStr11::operator !=(const algo::RspaceStr11 &rhs) const {
13504 return !algo::RspaceStr11_Eq(const_cast<algo::RspaceStr11&>(*this),const_cast<algo::RspaceStr11&>(rhs));
13505}
13506
13507inline bool algo::RspaceStr11::operator ==(const algo::strptr &rhs) const {
13508 return algo::RspaceStr11_EqStrptr(const_cast<algo::RspaceStr11&>(*this),rhs);
13509}
13510inline algo::RspaceStr11::RspaceStr11() {
13511 algo::RspaceStr11_Init(*this);
13512}
13513
13514
13515// --- algo.RspaceStr11.ch.Getary
13516// Access string as array of chars
13517inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr11& parent) {
13518 int len = ch_N(parent);
13519 algo::aryptr<char> ret((char*)parent.ch, len);
13520 return ret;
13521}
13522
13523// --- algo.RspaceStr11.ch.HashStrptr
13524inline u32 algo::RspaceStr11_Hash(u32 prev, const algo::strptr &str) {
13525 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13526}
13527
13528// --- algo.RspaceStr11.ch.Init
13529inline void algo::ch_Init(algo::RspaceStr11 &parent) {
13530 memset(parent.ch, ' ', 11);
13531}
13532
13533// --- algo.RspaceStr11.ch.Max
13534// always return constant 11
13535inline int algo::ch_Max(algo::RspaceStr11& parent) {
13536 (void)parent;
13537 return 11;
13538}
13539
13540// --- algo.RspaceStr11.ch.N
13541inline int algo::ch_N(const algo::RspaceStr11& parent) {
13542 u64 ret;
13543 ret = 11;
13544 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13545 ret--;
13546 }
13547 return int(ret);
13548}
13549
13550// --- algo.RspaceStr11.ch.AssignStrptr
13551// Copy from strptr (operator=)
13552inline void algo::RspaceStr11::operator =(const algo::strptr &str) {
13553 ch_SetStrptr(*this, str);
13554}
13555
13556// --- algo.RspaceStr11.ch.Set
13557// Copy from same type
13558// Copy value from RHS.
13559inline void algo::RspaceStr11::operator =(const algo::RspaceStr11& parent) {
13560 memcpy(ch, parent.ch, 11);
13561}
13562
13563// --- algo.RspaceStr11.ch.Ctor
13564inline algo::RspaceStr11::RspaceStr11(const algo::RspaceStr11 &rhs) {
13565 operator =(rhs);
13566}
13567
13568// --- algo.RspaceStr11.ch.CtorStrptr
13569inline algo::RspaceStr11::RspaceStr11(const algo::strptr &rhs) {
13570 ch_SetStrptr(*this, rhs);
13571}
13572
13573// --- algo.RspaceStr11.ch.Cast
13574inline algo::RspaceStr11::operator algo::strptr () const {
13575 return ch_Getary(*this);
13576}
13577
13578// --- algo.RspaceStr11..Cmp
13579inline i32 algo::RspaceStr11_Cmp(algo::RspaceStr11& lhs, algo::RspaceStr11& rhs) {
13580 i32 retval = 0;
13581 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13582 return retval;
13583}
13584
13585// --- algo.RspaceStr11..Init
13586// Set all fields to initial values.
13587inline void algo::RspaceStr11_Init(algo::RspaceStr11& parent) {
13588 memset(parent.ch, ' ', 11);
13589}
13590
13591// --- algo.RspaceStr11..Eq
13592inline bool algo::RspaceStr11_Eq(algo::RspaceStr11& lhs, algo::RspaceStr11& rhs) {
13593 bool retval = true;
13594 retval = retval
13595 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13596 &&*(u16*)(lhs.ch+8) == *(u16*)(rhs.ch+8)
13597 &&*(u8*)(lhs.ch+10) == *(u8*)(rhs.ch+10);
13598 return retval;
13599}
13600
13601// --- algo.RspaceStr11..EqStrptr
13602inline bool algo::RspaceStr11_EqStrptr(const algo::RspaceStr11& lhs, const algo::strptr& rhs) {
13603 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13604}
13605
13606inline bool algo::RspaceStr12::operator ==(const algo::RspaceStr12 &rhs) const {
13607 return algo::RspaceStr12_Eq(const_cast<algo::RspaceStr12&>(*this),const_cast<algo::RspaceStr12&>(rhs));
13608}
13609
13610inline bool algo::RspaceStr12::operator !=(const algo::RspaceStr12 &rhs) const {
13611 return !algo::RspaceStr12_Eq(const_cast<algo::RspaceStr12&>(*this),const_cast<algo::RspaceStr12&>(rhs));
13612}
13613
13614inline bool algo::RspaceStr12::operator ==(const algo::strptr &rhs) const {
13615 return algo::RspaceStr12_EqStrptr(const_cast<algo::RspaceStr12&>(*this),rhs);
13616}
13617inline algo::RspaceStr12::RspaceStr12() {
13618 algo::RspaceStr12_Init(*this);
13619}
13620
13621
13622// --- algo.RspaceStr12.ch.Getary
13623// Access string as array of chars
13624inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr12& parent) {
13625 int len = ch_N(parent);
13626 algo::aryptr<char> ret((char*)parent.ch, len);
13627 return ret;
13628}
13629
13630// --- algo.RspaceStr12.ch.HashStrptr
13631inline u32 algo::RspaceStr12_Hash(u32 prev, const algo::strptr &str) {
13632 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13633}
13634
13635// --- algo.RspaceStr12.ch.Init
13636inline void algo::ch_Init(algo::RspaceStr12 &parent) {
13637 memset(parent.ch, ' ', 12);
13638}
13639
13640// --- algo.RspaceStr12.ch.Max
13641// always return constant 12
13642inline int algo::ch_Max(algo::RspaceStr12& parent) {
13643 (void)parent;
13644 return 12;
13645}
13646
13647// --- algo.RspaceStr12.ch.N
13648inline int algo::ch_N(const algo::RspaceStr12& parent) {
13649 u64 ret;
13650 ret = 12;
13651 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13652 ret--;
13653 }
13654 return int(ret);
13655}
13656
13657// --- algo.RspaceStr12.ch.AssignStrptr
13658// Copy from strptr (operator=)
13659inline void algo::RspaceStr12::operator =(const algo::strptr &str) {
13660 ch_SetStrptr(*this, str);
13661}
13662
13663// --- algo.RspaceStr12.ch.Set
13664// Copy from same type
13665// Copy value from RHS.
13666inline void algo::RspaceStr12::operator =(const algo::RspaceStr12& parent) {
13667 memcpy(ch, parent.ch, 12);
13668}
13669
13670// --- algo.RspaceStr12.ch.Ctor
13671inline algo::RspaceStr12::RspaceStr12(const algo::RspaceStr12 &rhs) {
13672 operator =(rhs);
13673}
13674
13675// --- algo.RspaceStr12.ch.CtorStrptr
13676inline algo::RspaceStr12::RspaceStr12(const algo::strptr &rhs) {
13677 ch_SetStrptr(*this, rhs);
13678}
13679
13680// --- algo.RspaceStr12.ch.Cast
13681inline algo::RspaceStr12::operator algo::strptr () const {
13682 return ch_Getary(*this);
13683}
13684
13685// --- algo.RspaceStr12..Cmp
13686inline i32 algo::RspaceStr12_Cmp(algo::RspaceStr12 lhs, algo::RspaceStr12 rhs) {
13687 i32 retval = 0;
13688 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13689 return retval;
13690}
13691
13692// --- algo.RspaceStr12..Init
13693// Set all fields to initial values.
13694inline void algo::RspaceStr12_Init(algo::RspaceStr12& parent) {
13695 memset(parent.ch, ' ', 12);
13696}
13697
13698// --- algo.RspaceStr12..Eq
13699inline bool algo::RspaceStr12_Eq(algo::RspaceStr12 lhs, algo::RspaceStr12 rhs) {
13700 bool retval = true;
13701 retval = retval
13702 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13703 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8);
13704 return retval;
13705}
13706
13707// --- algo.RspaceStr12..EqStrptr
13708inline bool algo::RspaceStr12_EqStrptr(algo::RspaceStr12 lhs, const algo::strptr& rhs) {
13709 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13710}
13711
13712inline bool algo::RspaceStr128::operator ==(const algo::RspaceStr128 &rhs) const {
13713 return algo::RspaceStr128_Eq(const_cast<algo::RspaceStr128&>(*this),const_cast<algo::RspaceStr128&>(rhs));
13714}
13715
13716inline bool algo::RspaceStr128::operator !=(const algo::RspaceStr128 &rhs) const {
13717 return !algo::RspaceStr128_Eq(const_cast<algo::RspaceStr128&>(*this),const_cast<algo::RspaceStr128&>(rhs));
13718}
13719
13720inline bool algo::RspaceStr128::operator ==(const algo::strptr &rhs) const {
13721 return algo::RspaceStr128_EqStrptr(const_cast<algo::RspaceStr128&>(*this),rhs);
13722}
13723inline algo::RspaceStr128::RspaceStr128() {
13724 algo::RspaceStr128_Init(*this);
13725}
13726
13727
13728// --- algo.RspaceStr128.ch.Getary
13729// Access string as array of chars
13730inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr128& parent) {
13731 int len = ch_N(parent);
13732 algo::aryptr<char> ret((char*)parent.ch, len);
13733 return ret;
13734}
13735
13736// --- algo.RspaceStr128.ch.HashStrptr
13737inline u32 algo::RspaceStr128_Hash(u32 prev, const algo::strptr &str) {
13738 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13739}
13740
13741// --- algo.RspaceStr128.ch.Init
13742inline void algo::ch_Init(algo::RspaceStr128 &parent) {
13743 memset(parent.ch, ' ', 128);
13744}
13745
13746// --- algo.RspaceStr128.ch.Max
13747// always return constant 128
13748inline int algo::ch_Max(algo::RspaceStr128& parent) {
13749 (void)parent;
13750 return 128;
13751}
13752
13753// --- algo.RspaceStr128.ch.N
13754inline int algo::ch_N(const algo::RspaceStr128& parent) {
13755 u64 ret;
13756 ret = 128;
13757 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13758 ret--;
13759 }
13760 return int(ret);
13761}
13762
13763// --- algo.RspaceStr128.ch.AssignStrptr
13764// Copy from strptr (operator=)
13765inline void algo::RspaceStr128::operator =(const algo::strptr &str) {
13766 ch_SetStrptr(*this, str);
13767}
13768
13769// --- algo.RspaceStr128.ch.Set
13770// Copy from same type
13771// Copy value from RHS.
13772inline void algo::RspaceStr128::operator =(const algo::RspaceStr128& parent) {
13773 memcpy(ch, parent.ch, 128);
13774}
13775
13776// --- algo.RspaceStr128.ch.Ctor
13777inline algo::RspaceStr128::RspaceStr128(const algo::RspaceStr128 &rhs) {
13778 operator =(rhs);
13779}
13780
13781// --- algo.RspaceStr128.ch.CtorStrptr
13782inline algo::RspaceStr128::RspaceStr128(const algo::strptr &rhs) {
13783 ch_SetStrptr(*this, rhs);
13784}
13785
13786// --- algo.RspaceStr128.ch.Cast
13787inline algo::RspaceStr128::operator algo::strptr () const {
13788 return ch_Getary(*this);
13789}
13790
13791// --- algo.RspaceStr128..Cmp
13792inline i32 algo::RspaceStr128_Cmp(algo::RspaceStr128 lhs, algo::RspaceStr128 rhs) {
13793 i32 retval = 0;
13794 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13795 return retval;
13796}
13797
13798// --- algo.RspaceStr128..Init
13799// Set all fields to initial values.
13800inline void algo::RspaceStr128_Init(algo::RspaceStr128& parent) {
13801 memset(parent.ch, ' ', 128);
13802}
13803
13804// --- algo.RspaceStr128..Eq
13805inline bool algo::RspaceStr128_Eq(algo::RspaceStr128 lhs, algo::RspaceStr128 rhs) {
13806 bool retval = true;
13807 retval = retval
13808 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13809 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
13810 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
13811 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
13812 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
13813 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
13814 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
13815 &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
13816 &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
13817 &&*(u64*)(lhs.ch+72) == *(u64*)(rhs.ch+72)
13818 &&*(u64*)(lhs.ch+80) == *(u64*)(rhs.ch+80)
13819 &&*(u64*)(lhs.ch+88) == *(u64*)(rhs.ch+88)
13820 &&*(u64*)(lhs.ch+96) == *(u64*)(rhs.ch+96)
13821 &&*(u64*)(lhs.ch+104) == *(u64*)(rhs.ch+104)
13822 &&*(u64*)(lhs.ch+112) == *(u64*)(rhs.ch+112)
13823 &&*(u64*)(lhs.ch+120) == *(u64*)(rhs.ch+120);
13824 return retval;
13825}
13826
13827// --- algo.RspaceStr128..EqStrptr
13828inline bool algo::RspaceStr128_EqStrptr(algo::RspaceStr128 lhs, const algo::strptr& rhs) {
13829 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13830}
13831
13832inline bool algo::RspaceStr14::operator ==(const algo::RspaceStr14 &rhs) const {
13833 return algo::RspaceStr14_Eq(const_cast<algo::RspaceStr14&>(*this),const_cast<algo::RspaceStr14&>(rhs));
13834}
13835
13836inline bool algo::RspaceStr14::operator !=(const algo::RspaceStr14 &rhs) const {
13837 return !algo::RspaceStr14_Eq(const_cast<algo::RspaceStr14&>(*this),const_cast<algo::RspaceStr14&>(rhs));
13838}
13839
13840inline bool algo::RspaceStr14::operator ==(const algo::strptr &rhs) const {
13841 return algo::RspaceStr14_EqStrptr(const_cast<algo::RspaceStr14&>(*this),rhs);
13842}
13843inline algo::RspaceStr14::RspaceStr14() {
13844 algo::RspaceStr14_Init(*this);
13845}
13846
13847
13848// --- algo.RspaceStr14.ch.Getary
13849// Access string as array of chars
13850inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr14& parent) {
13851 int len = ch_N(parent);
13852 algo::aryptr<char> ret((char*)parent.ch, len);
13853 return ret;
13854}
13855
13856// --- algo.RspaceStr14.ch.HashStrptr
13857inline u32 algo::RspaceStr14_Hash(u32 prev, const algo::strptr &str) {
13858 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13859}
13860
13861// --- algo.RspaceStr14.ch.Init
13862inline void algo::ch_Init(algo::RspaceStr14 &parent) {
13863 memset(parent.ch, ' ', 14);
13864}
13865
13866// --- algo.RspaceStr14.ch.Max
13867// always return constant 14
13868inline int algo::ch_Max(algo::RspaceStr14& parent) {
13869 (void)parent;
13870 return 14;
13871}
13872
13873// --- algo.RspaceStr14.ch.N
13874inline int algo::ch_N(const algo::RspaceStr14& parent) {
13875 u64 ret;
13876 ret = 14;
13877 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13878 ret--;
13879 }
13880 return int(ret);
13881}
13882
13883// --- algo.RspaceStr14.ch.AssignStrptr
13884// Copy from strptr (operator=)
13885inline void algo::RspaceStr14::operator =(const algo::strptr &str) {
13886 ch_SetStrptr(*this, str);
13887}
13888
13889// --- algo.RspaceStr14.ch.Set
13890// Copy from same type
13891// Copy value from RHS.
13892inline void algo::RspaceStr14::operator =(const algo::RspaceStr14& parent) {
13893 memcpy(ch, parent.ch, 14);
13894}
13895
13896// --- algo.RspaceStr14.ch.Ctor
13897inline algo::RspaceStr14::RspaceStr14(const algo::RspaceStr14 &rhs) {
13898 operator =(rhs);
13899}
13900
13901// --- algo.RspaceStr14.ch.CtorStrptr
13902inline algo::RspaceStr14::RspaceStr14(const algo::strptr &rhs) {
13903 ch_SetStrptr(*this, rhs);
13904}
13905
13906// --- algo.RspaceStr14.ch.Cast
13907inline algo::RspaceStr14::operator algo::strptr () const {
13908 return ch_Getary(*this);
13909}
13910
13911// --- algo.RspaceStr14..Cmp
13912inline i32 algo::RspaceStr14_Cmp(algo::RspaceStr14 lhs, algo::RspaceStr14 rhs) {
13913 i32 retval = 0;
13914 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
13915 return retval;
13916}
13917
13918// --- algo.RspaceStr14..Init
13919// Set all fields to initial values.
13920inline void algo::RspaceStr14_Init(algo::RspaceStr14& parent) {
13921 memset(parent.ch, ' ', 14);
13922}
13923
13924// --- algo.RspaceStr14..Eq
13925inline bool algo::RspaceStr14_Eq(algo::RspaceStr14 lhs, algo::RspaceStr14 rhs) {
13926 bool retval = true;
13927 retval = retval
13928 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
13929 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
13930 &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12);
13931 return retval;
13932}
13933
13934// --- algo.RspaceStr14..EqStrptr
13935inline bool algo::RspaceStr14_EqStrptr(algo::RspaceStr14 lhs, const algo::strptr& rhs) {
13936 return algo::strptr_Eq(ch_Getary(lhs), rhs);
13937}
13938
13939inline bool algo::RspaceStr15::operator ==(const algo::RspaceStr15 &rhs) const {
13940 return algo::RspaceStr15_Eq(const_cast<algo::RspaceStr15&>(*this),const_cast<algo::RspaceStr15&>(rhs));
13941}
13942
13943inline bool algo::RspaceStr15::operator !=(const algo::RspaceStr15 &rhs) const {
13944 return !algo::RspaceStr15_Eq(const_cast<algo::RspaceStr15&>(*this),const_cast<algo::RspaceStr15&>(rhs));
13945}
13946
13947inline bool algo::RspaceStr15::operator ==(const algo::strptr &rhs) const {
13948 return algo::RspaceStr15_EqStrptr(const_cast<algo::RspaceStr15&>(*this),rhs);
13949}
13950inline algo::RspaceStr15::RspaceStr15() {
13951 algo::RspaceStr15_Init(*this);
13952}
13953
13954
13955// --- algo.RspaceStr15.ch.Getary
13956// Access string as array of chars
13957inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr15& parent) {
13958 int len = ch_N(parent);
13959 algo::aryptr<char> ret((char*)parent.ch, len);
13960 return ret;
13961}
13962
13963// --- algo.RspaceStr15.ch.HashStrptr
13964inline u32 algo::RspaceStr15_Hash(u32 prev, const algo::strptr &str) {
13965 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
13966}
13967
13968// --- algo.RspaceStr15.ch.Init
13969inline void algo::ch_Init(algo::RspaceStr15 &parent) {
13970 memset(parent.ch, ' ', 15);
13971}
13972
13973// --- algo.RspaceStr15.ch.Max
13974// always return constant 15
13975inline int algo::ch_Max(algo::RspaceStr15& parent) {
13976 (void)parent;
13977 return 15;
13978}
13979
13980// --- algo.RspaceStr15.ch.N
13981inline int algo::ch_N(const algo::RspaceStr15& parent) {
13982 u64 ret;
13983 ret = 15;
13984 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
13985 ret--;
13986 }
13987 return int(ret);
13988}
13989
13990// --- algo.RspaceStr15.ch.AssignStrptr
13991// Copy from strptr (operator=)
13992inline void algo::RspaceStr15::operator =(const algo::strptr &str) {
13993 ch_SetStrptr(*this, str);
13994}
13995
13996// --- algo.RspaceStr15.ch.Set
13997// Copy from same type
13998// Copy value from RHS.
13999inline void algo::RspaceStr15::operator =(const algo::RspaceStr15& parent) {
14000 memcpy(ch, parent.ch, 15);
14001}
14002
14003// --- algo.RspaceStr15.ch.Ctor
14004inline algo::RspaceStr15::RspaceStr15(const algo::RspaceStr15 &rhs) {
14005 operator =(rhs);
14006}
14007
14008// --- algo.RspaceStr15.ch.CtorStrptr
14009inline algo::RspaceStr15::RspaceStr15(const algo::strptr &rhs) {
14010 ch_SetStrptr(*this, rhs);
14011}
14012
14013// --- algo.RspaceStr15.ch.Cast
14014inline algo::RspaceStr15::operator algo::strptr () const {
14015 return ch_Getary(*this);
14016}
14017
14018// --- algo.RspaceStr15..Cmp
14019inline i32 algo::RspaceStr15_Cmp(algo::RspaceStr15 lhs, algo::RspaceStr15 rhs) {
14020 i32 retval = 0;
14021 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14022 return retval;
14023}
14024
14025// --- algo.RspaceStr15..Init
14026// Set all fields to initial values.
14027inline void algo::RspaceStr15_Init(algo::RspaceStr15& parent) {
14028 memset(parent.ch, ' ', 15);
14029}
14030
14031// --- algo.RspaceStr15..Eq
14032inline bool algo::RspaceStr15_Eq(algo::RspaceStr15 lhs, algo::RspaceStr15 rhs) {
14033 bool retval = true;
14034 retval = retval
14035 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14036 &&*(u32*)(lhs.ch+8) == *(u32*)(rhs.ch+8)
14037 &&*(u16*)(lhs.ch+12) == *(u16*)(rhs.ch+12)
14038 &&*(u8*)(lhs.ch+14) == *(u8*)(rhs.ch+14);
14039 return retval;
14040}
14041
14042// --- algo.RspaceStr15..EqStrptr
14043inline bool algo::RspaceStr15_EqStrptr(algo::RspaceStr15 lhs, const algo::strptr& rhs) {
14044 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14045}
14046inline algo::RspaceStr16::RspaceStr16() {
14047 algo::RspaceStr16_Init(*this);
14048}
14049
14050
14051// --- algo.RspaceStr16.ch.Getary
14052// Access string as array of chars
14053inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr16& parent) {
14054 int len = ch_N(parent);
14055 algo::aryptr<char> ret((char*)parent.ch, len);
14056 return ret;
14057}
14058
14059// --- algo.RspaceStr16.ch.HashStrptr
14060inline u32 algo::RspaceStr16_Hash(u32 prev, const algo::strptr &str) {
14061 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14062}
14063
14064// --- algo.RspaceStr16.ch.Init
14065inline void algo::ch_Init(algo::RspaceStr16 &parent) {
14066 memset(parent.ch, ' ', 16);
14067}
14068
14069// --- algo.RspaceStr16.ch.Max
14070// always return constant 16
14071inline int algo::ch_Max(algo::RspaceStr16& parent) {
14072 (void)parent;
14073 return 16;
14074}
14075
14076// --- algo.RspaceStr16.ch.N
14077inline int algo::ch_N(const algo::RspaceStr16& parent) {
14078 u64 ret;
14079 ret = 16;
14080 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14081 ret--;
14082 }
14083 return int(ret);
14084}
14085
14086// --- algo.RspaceStr16.ch.AssignStrptr
14087// Copy from strptr (operator=)
14088inline void algo::RspaceStr16::operator =(const algo::strptr &str) {
14089 ch_SetStrptr(*this, str);
14090}
14091
14092// --- algo.RspaceStr16.ch.Set
14093// Copy from same type
14094// Copy value from RHS.
14095inline void algo::RspaceStr16::operator =(const algo::RspaceStr16& parent) {
14096 memcpy(ch, parent.ch, 16);
14097}
14098
14099// --- algo.RspaceStr16.ch.Ctor
14100inline algo::RspaceStr16::RspaceStr16(const algo::RspaceStr16 &rhs) {
14101 operator =(rhs);
14102}
14103
14104// --- algo.RspaceStr16.ch.CtorStrptr
14105inline algo::RspaceStr16::RspaceStr16(const algo::strptr &rhs) {
14106 ch_SetStrptr(*this, rhs);
14107}
14108
14109// --- algo.RspaceStr16.ch.Cast
14110inline algo::RspaceStr16::operator algo::strptr () const {
14111 return ch_Getary(*this);
14112}
14113
14114// --- algo.RspaceStr16..Lt
14115inline bool algo::RspaceStr16_Lt(algo::RspaceStr16 lhs, algo::RspaceStr16 rhs) {
14116 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
14117}
14118
14119// --- algo.RspaceStr16..Cmp
14120inline i32 algo::RspaceStr16_Cmp(algo::RspaceStr16 lhs, algo::RspaceStr16 rhs) {
14121 i32 retval = 0;
14122 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14123 return retval;
14124}
14125
14126// --- algo.RspaceStr16..Init
14127// Set all fields to initial values.
14128inline void algo::RspaceStr16_Init(algo::RspaceStr16& parent) {
14129 memset(parent.ch, ' ', 16);
14130}
14131
14132// --- algo.RspaceStr16..Eq
14133inline bool algo::RspaceStr16_Eq(algo::RspaceStr16 lhs, algo::RspaceStr16 rhs) {
14134 bool retval = true;
14135 retval = retval
14136 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14137 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8);
14138 return retval;
14139}
14140
14141// --- algo.RspaceStr16..Update
14142// Set value. Return true if new value is different from old value.
14143inline bool algo::RspaceStr16_Update(algo::RspaceStr16 &lhs, algo::RspaceStr16 rhs) {
14144 bool ret = !RspaceStr16_Eq(lhs, rhs); // compare values
14145 if (ret) {
14146 lhs = rhs; // update
14147 }
14148 return ret;
14149}
14150
14151// --- algo.RspaceStr16..EqStrptr
14152inline bool algo::RspaceStr16_EqStrptr(algo::RspaceStr16 lhs, const algo::strptr& rhs) {
14153 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14154}
14155
14156inline bool algo::RspaceStr18::operator ==(const algo::RspaceStr18 &rhs) const {
14157 return algo::RspaceStr18_Eq(const_cast<algo::RspaceStr18&>(*this),const_cast<algo::RspaceStr18&>(rhs));
14158}
14159
14160inline bool algo::RspaceStr18::operator !=(const algo::RspaceStr18 &rhs) const {
14161 return !algo::RspaceStr18_Eq(const_cast<algo::RspaceStr18&>(*this),const_cast<algo::RspaceStr18&>(rhs));
14162}
14163
14164inline bool algo::RspaceStr18::operator ==(const algo::strptr &rhs) const {
14165 return algo::RspaceStr18_EqStrptr(const_cast<algo::RspaceStr18&>(*this),rhs);
14166}
14167inline algo::RspaceStr18::RspaceStr18() {
14168 algo::RspaceStr18_Init(*this);
14169}
14170
14171
14172// --- algo.RspaceStr18.ch.Getary
14173// Access string as array of chars
14174inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr18& parent) {
14175 int len = ch_N(parent);
14176 algo::aryptr<char> ret((char*)parent.ch, len);
14177 return ret;
14178}
14179
14180// --- algo.RspaceStr18.ch.HashStrptr
14181inline u32 algo::RspaceStr18_Hash(u32 prev, const algo::strptr &str) {
14182 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14183}
14184
14185// --- algo.RspaceStr18.ch.Init
14186inline void algo::ch_Init(algo::RspaceStr18 &parent) {
14187 memset(parent.ch, ' ', 18);
14188}
14189
14190// --- algo.RspaceStr18.ch.Max
14191// always return constant 18
14192inline int algo::ch_Max(algo::RspaceStr18& parent) {
14193 (void)parent;
14194 return 18;
14195}
14196
14197// --- algo.RspaceStr18.ch.N
14198inline int algo::ch_N(const algo::RspaceStr18& parent) {
14199 u64 ret;
14200 ret = 18;
14201 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14202 ret--;
14203 }
14204 return int(ret);
14205}
14206
14207// --- algo.RspaceStr18.ch.AssignStrptr
14208// Copy from strptr (operator=)
14209inline void algo::RspaceStr18::operator =(const algo::strptr &str) {
14210 ch_SetStrptr(*this, str);
14211}
14212
14213// --- algo.RspaceStr18.ch.Set
14214// Copy from same type
14215// Copy value from RHS.
14216inline void algo::RspaceStr18::operator =(const algo::RspaceStr18& parent) {
14217 memcpy(ch, parent.ch, 18);
14218}
14219
14220// --- algo.RspaceStr18.ch.Ctor
14221inline algo::RspaceStr18::RspaceStr18(const algo::RspaceStr18 &rhs) {
14222 operator =(rhs);
14223}
14224
14225// --- algo.RspaceStr18.ch.CtorStrptr
14226inline algo::RspaceStr18::RspaceStr18(const algo::strptr &rhs) {
14227 ch_SetStrptr(*this, rhs);
14228}
14229
14230// --- algo.RspaceStr18.ch.Cast
14231inline algo::RspaceStr18::operator algo::strptr () const {
14232 return ch_Getary(*this);
14233}
14234
14235// --- algo.RspaceStr18..Cmp
14236inline i32 algo::RspaceStr18_Cmp(algo::RspaceStr18 lhs, algo::RspaceStr18 rhs) {
14237 i32 retval = 0;
14238 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14239 return retval;
14240}
14241
14242// --- algo.RspaceStr18..Init
14243// Set all fields to initial values.
14244inline void algo::RspaceStr18_Init(algo::RspaceStr18& parent) {
14245 memset(parent.ch, ' ', 18);
14246}
14247
14248// --- algo.RspaceStr18..Eq
14249inline bool algo::RspaceStr18_Eq(algo::RspaceStr18 lhs, algo::RspaceStr18 rhs) {
14250 bool retval = true;
14251 retval = retval
14252 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14253 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14254 &&*(u16*)(lhs.ch+16) == *(u16*)(rhs.ch+16);
14255 return retval;
14256}
14257
14258// --- algo.RspaceStr18..EqStrptr
14259inline bool algo::RspaceStr18_EqStrptr(algo::RspaceStr18 lhs, const algo::strptr& rhs) {
14260 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14261}
14262
14263inline bool algo::RspaceStr2::operator ==(const algo::RspaceStr2 &rhs) const {
14264 return algo::RspaceStr2_Eq(const_cast<algo::RspaceStr2&>(*this),const_cast<algo::RspaceStr2&>(rhs));
14265}
14266
14267inline bool algo::RspaceStr2::operator !=(const algo::RspaceStr2 &rhs) const {
14268 return !algo::RspaceStr2_Eq(const_cast<algo::RspaceStr2&>(*this),const_cast<algo::RspaceStr2&>(rhs));
14269}
14270
14271inline bool algo::RspaceStr2::operator ==(const algo::strptr &rhs) const {
14272 return algo::RspaceStr2_EqStrptr(const_cast<algo::RspaceStr2&>(*this),rhs);
14273}
14274inline algo::RspaceStr2::RspaceStr2() {
14275 algo::RspaceStr2_Init(*this);
14276}
14277
14278
14279// --- algo.RspaceStr2.ch.Getary
14280// Access string as array of chars
14281inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr2& parent) {
14282 int len = ch_N(parent);
14283 algo::aryptr<char> ret((char*)parent.ch, len);
14284 return ret;
14285}
14286
14287// --- algo.RspaceStr2.ch.HashStrptr
14288inline u32 algo::RspaceStr2_Hash(u32 prev, const algo::strptr &str) {
14289 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14290}
14291
14292// --- algo.RspaceStr2.ch.Init
14293inline void algo::ch_Init(algo::RspaceStr2 &parent) {
14294 memset(parent.ch, ' ', 2);
14295}
14296
14297// --- algo.RspaceStr2.ch.Max
14298// always return constant 2
14299inline int algo::ch_Max(algo::RspaceStr2& parent) {
14300 (void)parent;
14301 return 2;
14302}
14303
14304// --- algo.RspaceStr2.ch.N
14305inline int algo::ch_N(const algo::RspaceStr2& parent) {
14306 u64 ret;
14307 ret = 2;
14308 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14309 ret--;
14310 }
14311 return int(ret);
14312}
14313
14314// --- algo.RspaceStr2.ch.AssignStrptr
14315// Copy from strptr (operator=)
14316inline void algo::RspaceStr2::operator =(const algo::strptr &str) {
14317 ch_SetStrptr(*this, str);
14318}
14319
14320// --- algo.RspaceStr2.ch.Set
14321// Copy from same type
14322// Copy value from RHS.
14323inline void algo::RspaceStr2::operator =(const algo::RspaceStr2& parent) {
14324 memcpy(ch, parent.ch, 2);
14325}
14326
14327// --- algo.RspaceStr2.ch.Ctor
14328inline algo::RspaceStr2::RspaceStr2(const algo::RspaceStr2 &rhs) {
14329 operator =(rhs);
14330}
14331
14332// --- algo.RspaceStr2.ch.CtorStrptr
14333inline algo::RspaceStr2::RspaceStr2(const algo::strptr &rhs) {
14334 ch_SetStrptr(*this, rhs);
14335}
14336
14337// --- algo.RspaceStr2.ch.Cast
14338inline algo::RspaceStr2::operator algo::strptr () const {
14339 return ch_Getary(*this);
14340}
14341
14342// --- algo.RspaceStr2..Cmp
14343inline i32 algo::RspaceStr2_Cmp(algo::RspaceStr2 lhs, algo::RspaceStr2 rhs) {
14344 i32 retval = 0;
14345 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14346 return retval;
14347}
14348
14349// --- algo.RspaceStr2..Init
14350// Set all fields to initial values.
14351inline void algo::RspaceStr2_Init(algo::RspaceStr2& parent) {
14352 memset(parent.ch, ' ', 2);
14353}
14354
14355// --- algo.RspaceStr2..Eq
14356inline bool algo::RspaceStr2_Eq(algo::RspaceStr2 lhs, algo::RspaceStr2 rhs) {
14357 bool retval = true;
14358 retval = retval
14359 &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0);
14360 return retval;
14361}
14362
14363// --- algo.RspaceStr2..EqStrptr
14364inline bool algo::RspaceStr2_EqStrptr(algo::RspaceStr2 lhs, const algo::strptr& rhs) {
14365 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14366}
14367
14368inline bool algo::RspaceStr20::operator ==(const algo::RspaceStr20 &rhs) const {
14369 return algo::RspaceStr20_Eq(const_cast<algo::RspaceStr20&>(*this),const_cast<algo::RspaceStr20&>(rhs));
14370}
14371
14372inline bool algo::RspaceStr20::operator !=(const algo::RspaceStr20 &rhs) const {
14373 return !algo::RspaceStr20_Eq(const_cast<algo::RspaceStr20&>(*this),const_cast<algo::RspaceStr20&>(rhs));
14374}
14375
14376inline bool algo::RspaceStr20::operator ==(const algo::strptr &rhs) const {
14377 return algo::RspaceStr20_EqStrptr(const_cast<algo::RspaceStr20&>(*this),rhs);
14378}
14379inline algo::RspaceStr20::RspaceStr20() {
14380 algo::RspaceStr20_Init(*this);
14381}
14382
14383
14384// --- algo.RspaceStr20.ch.Getary
14385// Access string as array of chars
14386inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr20& parent) {
14387 int len = ch_N(parent);
14388 algo::aryptr<char> ret((char*)parent.ch, len);
14389 return ret;
14390}
14391
14392// --- algo.RspaceStr20.ch.HashStrptr
14393inline u32 algo::RspaceStr20_Hash(u32 prev, const algo::strptr &str) {
14394 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14395}
14396
14397// --- algo.RspaceStr20.ch.Init
14398inline void algo::ch_Init(algo::RspaceStr20 &parent) {
14399 memset(parent.ch, ' ', 20);
14400}
14401
14402// --- algo.RspaceStr20.ch.Max
14403// always return constant 20
14404inline int algo::ch_Max(algo::RspaceStr20& parent) {
14405 (void)parent;
14406 return 20;
14407}
14408
14409// --- algo.RspaceStr20.ch.N
14410inline int algo::ch_N(const algo::RspaceStr20& parent) {
14411 u64 ret;
14412 ret = 20;
14413 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14414 ret--;
14415 }
14416 return int(ret);
14417}
14418
14419// --- algo.RspaceStr20.ch.AssignStrptr
14420// Copy from strptr (operator=)
14421inline void algo::RspaceStr20::operator =(const algo::strptr &str) {
14422 ch_SetStrptr(*this, str);
14423}
14424
14425// --- algo.RspaceStr20.ch.Set
14426// Copy from same type
14427// Copy value from RHS.
14428inline void algo::RspaceStr20::operator =(const algo::RspaceStr20& parent) {
14429 memcpy(ch, parent.ch, 20);
14430}
14431
14432// --- algo.RspaceStr20.ch.Ctor
14433inline algo::RspaceStr20::RspaceStr20(const algo::RspaceStr20 &rhs) {
14434 operator =(rhs);
14435}
14436
14437// --- algo.RspaceStr20.ch.CtorStrptr
14438inline algo::RspaceStr20::RspaceStr20(const algo::strptr &rhs) {
14439 ch_SetStrptr(*this, rhs);
14440}
14441
14442// --- algo.RspaceStr20.ch.Cast
14443inline algo::RspaceStr20::operator algo::strptr () const {
14444 return ch_Getary(*this);
14445}
14446
14447// --- algo.RspaceStr20..Cmp
14448inline i32 algo::RspaceStr20_Cmp(algo::RspaceStr20 lhs, algo::RspaceStr20 rhs) {
14449 i32 retval = 0;
14450 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14451 return retval;
14452}
14453
14454// --- algo.RspaceStr20..Init
14455// Set all fields to initial values.
14456inline void algo::RspaceStr20_Init(algo::RspaceStr20& parent) {
14457 memset(parent.ch, ' ', 20);
14458}
14459
14460// --- algo.RspaceStr20..Eq
14461inline bool algo::RspaceStr20_Eq(algo::RspaceStr20 lhs, algo::RspaceStr20 rhs) {
14462 bool retval = true;
14463 retval = retval
14464 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14465 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14466 &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16);
14467 return retval;
14468}
14469
14470// --- algo.RspaceStr20..EqStrptr
14471inline bool algo::RspaceStr20_EqStrptr(algo::RspaceStr20 lhs, const algo::strptr& rhs) {
14472 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14473}
14474
14475inline bool algo::RspaceStr200::operator ==(const algo::RspaceStr200 &rhs) const {
14476 return algo::RspaceStr200_Eq(const_cast<algo::RspaceStr200&>(*this),const_cast<algo::RspaceStr200&>(rhs));
14477}
14478
14479inline bool algo::RspaceStr200::operator !=(const algo::RspaceStr200 &rhs) const {
14480 return !algo::RspaceStr200_Eq(const_cast<algo::RspaceStr200&>(*this),const_cast<algo::RspaceStr200&>(rhs));
14481}
14482
14483inline bool algo::RspaceStr200::operator ==(const algo::strptr &rhs) const {
14484 return algo::RspaceStr200_EqStrptr(const_cast<algo::RspaceStr200&>(*this),rhs);
14485}
14486inline algo::RspaceStr200::RspaceStr200() {
14487 algo::RspaceStr200_Init(*this);
14488}
14489
14490
14491// --- algo.RspaceStr200.ch.Getary
14492// Access string as array of chars
14493inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr200& parent) {
14494 int len = ch_N(parent);
14495 algo::aryptr<char> ret((char*)parent.ch, len);
14496 return ret;
14497}
14498
14499// --- algo.RspaceStr200.ch.HashStrptr
14500inline u32 algo::RspaceStr200_Hash(u32 prev, const algo::strptr &str) {
14501 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14502}
14503
14504// --- algo.RspaceStr200.ch.Init
14505inline void algo::ch_Init(algo::RspaceStr200 &parent) {
14506 memset(parent.ch, ' ', 200);
14507}
14508
14509// --- algo.RspaceStr200.ch.Max
14510// always return constant 200
14511inline int algo::ch_Max(algo::RspaceStr200& parent) {
14512 (void)parent;
14513 return 200;
14514}
14515
14516// --- algo.RspaceStr200.ch.N
14517inline int algo::ch_N(const algo::RspaceStr200& parent) {
14518 u64 ret;
14519 ret = 200;
14520 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14521 ret--;
14522 }
14523 return int(ret);
14524}
14525
14526// --- algo.RspaceStr200.ch.AssignStrptr
14527// Copy from strptr (operator=)
14528inline void algo::RspaceStr200::operator =(const algo::strptr &str) {
14529 ch_SetStrptr(*this, str);
14530}
14531
14532// --- algo.RspaceStr200.ch.Set
14533// Copy from same type
14534// Copy value from RHS.
14535inline void algo::RspaceStr200::operator =(const algo::RspaceStr200& parent) {
14536 memcpy(ch, parent.ch, 200);
14537}
14538
14539// --- algo.RspaceStr200.ch.Ctor
14540inline algo::RspaceStr200::RspaceStr200(const algo::RspaceStr200 &rhs) {
14541 operator =(rhs);
14542}
14543
14544// --- algo.RspaceStr200.ch.CtorStrptr
14545inline algo::RspaceStr200::RspaceStr200(const algo::strptr &rhs) {
14546 ch_SetStrptr(*this, rhs);
14547}
14548
14549// --- algo.RspaceStr200.ch.Cast
14550inline algo::RspaceStr200::operator algo::strptr () const {
14551 return ch_Getary(*this);
14552}
14553
14554// --- algo.RspaceStr200..Cmp
14555inline i32 algo::RspaceStr200_Cmp(algo::RspaceStr200& lhs, algo::RspaceStr200& rhs) {
14556 i32 retval = 0;
14557 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14558 return retval;
14559}
14560
14561// --- algo.RspaceStr200..Init
14562// Set all fields to initial values.
14563inline void algo::RspaceStr200_Init(algo::RspaceStr200& parent) {
14564 memset(parent.ch, ' ', 200);
14565}
14566
14567// --- algo.RspaceStr200..Eq
14568inline bool algo::RspaceStr200_Eq(algo::RspaceStr200& lhs, algo::RspaceStr200& rhs) {
14569 bool retval = true;
14570 for (int i=0; i<25 && retval; i++) {
14571 retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
14572 }
14573 return retval;
14574}
14575
14576// --- algo.RspaceStr200..EqStrptr
14577inline bool algo::RspaceStr200_EqStrptr(const algo::RspaceStr200& lhs, const algo::strptr& rhs) {
14578 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14579}
14580
14581inline bool algo::RspaceStr21::operator ==(const algo::RspaceStr21 &rhs) const {
14582 return algo::RspaceStr21_Eq(const_cast<algo::RspaceStr21&>(*this),const_cast<algo::RspaceStr21&>(rhs));
14583}
14584
14585inline bool algo::RspaceStr21::operator !=(const algo::RspaceStr21 &rhs) const {
14586 return !algo::RspaceStr21_Eq(const_cast<algo::RspaceStr21&>(*this),const_cast<algo::RspaceStr21&>(rhs));
14587}
14588
14589inline bool algo::RspaceStr21::operator ==(const algo::strptr &rhs) const {
14590 return algo::RspaceStr21_EqStrptr(const_cast<algo::RspaceStr21&>(*this),rhs);
14591}
14592inline algo::RspaceStr21::RspaceStr21() {
14593 algo::RspaceStr21_Init(*this);
14594}
14595
14596
14597// --- algo.RspaceStr21.ch.Getary
14598// Access string as array of chars
14599inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr21& parent) {
14600 int len = ch_N(parent);
14601 algo::aryptr<char> ret((char*)parent.ch, len);
14602 return ret;
14603}
14604
14605// --- algo.RspaceStr21.ch.HashStrptr
14606inline u32 algo::RspaceStr21_Hash(u32 prev, const algo::strptr &str) {
14607 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14608}
14609
14610// --- algo.RspaceStr21.ch.Init
14611inline void algo::ch_Init(algo::RspaceStr21 &parent) {
14612 memset(parent.ch, ' ', 21);
14613}
14614
14615// --- algo.RspaceStr21.ch.Max
14616// always return constant 21
14617inline int algo::ch_Max(algo::RspaceStr21& parent) {
14618 (void)parent;
14619 return 21;
14620}
14621
14622// --- algo.RspaceStr21.ch.N
14623inline int algo::ch_N(const algo::RspaceStr21& parent) {
14624 u64 ret;
14625 ret = 21;
14626 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14627 ret--;
14628 }
14629 return int(ret);
14630}
14631
14632// --- algo.RspaceStr21.ch.AssignStrptr
14633// Copy from strptr (operator=)
14634inline void algo::RspaceStr21::operator =(const algo::strptr &str) {
14635 ch_SetStrptr(*this, str);
14636}
14637
14638// --- algo.RspaceStr21.ch.Set
14639// Copy from same type
14640// Copy value from RHS.
14641inline void algo::RspaceStr21::operator =(const algo::RspaceStr21& parent) {
14642 memcpy(ch, parent.ch, 21);
14643}
14644
14645// --- algo.RspaceStr21.ch.Ctor
14646inline algo::RspaceStr21::RspaceStr21(const algo::RspaceStr21 &rhs) {
14647 operator =(rhs);
14648}
14649
14650// --- algo.RspaceStr21.ch.CtorStrptr
14651inline algo::RspaceStr21::RspaceStr21(const algo::strptr &rhs) {
14652 ch_SetStrptr(*this, rhs);
14653}
14654
14655// --- algo.RspaceStr21.ch.Cast
14656inline algo::RspaceStr21::operator algo::strptr () const {
14657 return ch_Getary(*this);
14658}
14659
14660// --- algo.RspaceStr21..Cmp
14661inline i32 algo::RspaceStr21_Cmp(algo::RspaceStr21& lhs, algo::RspaceStr21& rhs) {
14662 i32 retval = 0;
14663 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14664 return retval;
14665}
14666
14667// --- algo.RspaceStr21..Init
14668// Set all fields to initial values.
14669inline void algo::RspaceStr21_Init(algo::RspaceStr21& parent) {
14670 memset(parent.ch, ' ', 21);
14671}
14672
14673// --- algo.RspaceStr21..Eq
14674inline bool algo::RspaceStr21_Eq(algo::RspaceStr21& lhs, algo::RspaceStr21& rhs) {
14675 bool retval = true;
14676 retval = retval
14677 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14678 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14679 &&*(u32*)(lhs.ch+16) == *(u32*)(rhs.ch+16)
14680 &&*(u8*)(lhs.ch+20) == *(u8*)(rhs.ch+20);
14681 return retval;
14682}
14683
14684// --- algo.RspaceStr21..EqStrptr
14685inline bool algo::RspaceStr21_EqStrptr(const algo::RspaceStr21& lhs, const algo::strptr& rhs) {
14686 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14687}
14688inline algo::RspaceStr24::RspaceStr24() {
14689 algo::RspaceStr24_Init(*this);
14690}
14691
14692
14693// --- algo.RspaceStr24.ch.Getary
14694// Access string as array of chars
14695inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr24& parent) {
14696 int len = ch_N(parent);
14697 algo::aryptr<char> ret((char*)parent.ch, len);
14698 return ret;
14699}
14700
14701// --- algo.RspaceStr24.ch.HashStrptr
14702inline u32 algo::RspaceStr24_Hash(u32 prev, const algo::strptr &str) {
14703 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14704}
14705
14706// --- algo.RspaceStr24.ch.Init
14707inline void algo::ch_Init(algo::RspaceStr24 &parent) {
14708 memset(parent.ch, ' ', 24);
14709}
14710
14711// --- algo.RspaceStr24.ch.Max
14712// always return constant 24
14713inline int algo::ch_Max(algo::RspaceStr24& parent) {
14714 (void)parent;
14715 return 24;
14716}
14717
14718// --- algo.RspaceStr24.ch.N
14719inline int algo::ch_N(const algo::RspaceStr24& parent) {
14720 u64 ret;
14721 ret = 24;
14722 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14723 ret--;
14724 }
14725 return int(ret);
14726}
14727
14728// --- algo.RspaceStr24.ch.AssignStrptr
14729// Copy from strptr (operator=)
14730inline void algo::RspaceStr24::operator =(const algo::strptr &str) {
14731 ch_SetStrptr(*this, str);
14732}
14733
14734// --- algo.RspaceStr24.ch.Set
14735// Copy from same type
14736// Copy value from RHS.
14737inline void algo::RspaceStr24::operator =(const algo::RspaceStr24& parent) {
14738 memcpy(ch, parent.ch, 24);
14739}
14740
14741// --- algo.RspaceStr24.ch.Ctor
14742inline algo::RspaceStr24::RspaceStr24(const algo::RspaceStr24 &rhs) {
14743 operator =(rhs);
14744}
14745
14746// --- algo.RspaceStr24.ch.CtorStrptr
14747inline algo::RspaceStr24::RspaceStr24(const algo::strptr &rhs) {
14748 ch_SetStrptr(*this, rhs);
14749}
14750
14751// --- algo.RspaceStr24.ch.Cast
14752inline algo::RspaceStr24::operator algo::strptr () const {
14753 return ch_Getary(*this);
14754}
14755
14756// --- algo.RspaceStr24..Lt
14757inline bool algo::RspaceStr24_Lt(algo::RspaceStr24 lhs, algo::RspaceStr24 rhs) {
14758 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
14759}
14760
14761// --- algo.RspaceStr24..Cmp
14762inline i32 algo::RspaceStr24_Cmp(algo::RspaceStr24 lhs, algo::RspaceStr24 rhs) {
14763 i32 retval = 0;
14764 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14765 return retval;
14766}
14767
14768// --- algo.RspaceStr24..Init
14769// Set all fields to initial values.
14770inline void algo::RspaceStr24_Init(algo::RspaceStr24& parent) {
14771 memset(parent.ch, ' ', 24);
14772}
14773
14774// --- algo.RspaceStr24..Eq
14775inline bool algo::RspaceStr24_Eq(algo::RspaceStr24 lhs, algo::RspaceStr24 rhs) {
14776 bool retval = true;
14777 retval = retval
14778 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14779 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14780 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16);
14781 return retval;
14782}
14783
14784// --- algo.RspaceStr24..Update
14785// Set value. Return true if new value is different from old value.
14786inline bool algo::RspaceStr24_Update(algo::RspaceStr24 &lhs, algo::RspaceStr24 rhs) {
14787 bool ret = !RspaceStr24_Eq(lhs, rhs); // compare values
14788 if (ret) {
14789 lhs = rhs; // update
14790 }
14791 return ret;
14792}
14793
14794// --- algo.RspaceStr24..EqStrptr
14795inline bool algo::RspaceStr24_EqStrptr(algo::RspaceStr24 lhs, const algo::strptr& rhs) {
14796 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14797}
14798
14799inline bool algo::RspaceStr240::operator ==(const algo::RspaceStr240 &rhs) const {
14800 return algo::RspaceStr240_Eq(const_cast<algo::RspaceStr240&>(*this),const_cast<algo::RspaceStr240&>(rhs));
14801}
14802
14803inline bool algo::RspaceStr240::operator !=(const algo::RspaceStr240 &rhs) const {
14804 return !algo::RspaceStr240_Eq(const_cast<algo::RspaceStr240&>(*this),const_cast<algo::RspaceStr240&>(rhs));
14805}
14806
14807inline bool algo::RspaceStr240::operator ==(const algo::strptr &rhs) const {
14808 return algo::RspaceStr240_EqStrptr(const_cast<algo::RspaceStr240&>(*this),rhs);
14809}
14810inline algo::RspaceStr240::RspaceStr240() {
14811 algo::RspaceStr240_Init(*this);
14812}
14813
14814
14815// --- algo.RspaceStr240.ch.Getary
14816// Access string as array of chars
14817inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr240& parent) {
14818 int len = ch_N(parent);
14819 algo::aryptr<char> ret((char*)parent.ch, len);
14820 return ret;
14821}
14822
14823// --- algo.RspaceStr240.ch.HashStrptr
14824inline u32 algo::RspaceStr240_Hash(u32 prev, const algo::strptr &str) {
14825 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14826}
14827
14828// --- algo.RspaceStr240.ch.Init
14829inline void algo::ch_Init(algo::RspaceStr240 &parent) {
14830 memset(parent.ch, ' ', 240);
14831}
14832
14833// --- algo.RspaceStr240.ch.Max
14834// always return constant 240
14835inline int algo::ch_Max(algo::RspaceStr240& parent) {
14836 (void)parent;
14837 return 240;
14838}
14839
14840// --- algo.RspaceStr240.ch.N
14841inline int algo::ch_N(const algo::RspaceStr240& parent) {
14842 u64 ret;
14843 ret = 240;
14844 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14845 ret--;
14846 }
14847 return int(ret);
14848}
14849
14850// --- algo.RspaceStr240.ch.AssignStrptr
14851// Copy from strptr (operator=)
14852inline void algo::RspaceStr240::operator =(const algo::strptr &str) {
14853 ch_SetStrptr(*this, str);
14854}
14855
14856// --- algo.RspaceStr240.ch.Set
14857// Copy from same type
14858// Copy value from RHS.
14859inline void algo::RspaceStr240::operator =(const algo::RspaceStr240& parent) {
14860 memcpy(ch, parent.ch, 240);
14861}
14862
14863// --- algo.RspaceStr240.ch.Ctor
14864inline algo::RspaceStr240::RspaceStr240(const algo::RspaceStr240 &rhs) {
14865 operator =(rhs);
14866}
14867
14868// --- algo.RspaceStr240.ch.CtorStrptr
14869inline algo::RspaceStr240::RspaceStr240(const algo::strptr &rhs) {
14870 ch_SetStrptr(*this, rhs);
14871}
14872
14873// --- algo.RspaceStr240.ch.Cast
14874inline algo::RspaceStr240::operator algo::strptr () const {
14875 return ch_Getary(*this);
14876}
14877
14878// --- algo.RspaceStr240..Cmp
14879inline i32 algo::RspaceStr240_Cmp(algo::RspaceStr240& lhs, algo::RspaceStr240& rhs) {
14880 i32 retval = 0;
14881 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14882 return retval;
14883}
14884
14885// --- algo.RspaceStr240..Init
14886// Set all fields to initial values.
14887inline void algo::RspaceStr240_Init(algo::RspaceStr240& parent) {
14888 memset(parent.ch, ' ', 240);
14889}
14890
14891// --- algo.RspaceStr240..Eq
14892inline bool algo::RspaceStr240_Eq(algo::RspaceStr240& lhs, algo::RspaceStr240& rhs) {
14893 bool retval = true;
14894 for (int i=0; i<30 && retval; i++) {
14895 retval = ((u64*)lhs.ch)[i] == ((u64*)rhs.ch)[i];
14896 }
14897 return retval;
14898}
14899
14900// --- algo.RspaceStr240..EqStrptr
14901inline bool algo::RspaceStr240_EqStrptr(const algo::RspaceStr240& lhs, const algo::strptr& rhs) {
14902 return algo::strptr_Eq(ch_Getary(lhs), rhs);
14903}
14904inline algo::RspaceStr25::RspaceStr25() {
14905 algo::RspaceStr25_Init(*this);
14906}
14907
14908
14909// --- algo.RspaceStr25.ch.Getary
14910// Access string as array of chars
14911inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr25& parent) {
14912 int len = ch_N(parent);
14913 algo::aryptr<char> ret((char*)parent.ch, len);
14914 return ret;
14915}
14916
14917// --- algo.RspaceStr25.ch.HashStrptr
14918inline u32 algo::RspaceStr25_Hash(u32 prev, const algo::strptr &str) {
14919 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
14920}
14921
14922// --- algo.RspaceStr25.ch.Init
14923inline void algo::ch_Init(algo::RspaceStr25 &parent) {
14924 memset(parent.ch, ' ', 25);
14925}
14926
14927// --- algo.RspaceStr25.ch.Max
14928// always return constant 25
14929inline int algo::ch_Max(algo::RspaceStr25& parent) {
14930 (void)parent;
14931 return 25;
14932}
14933
14934// --- algo.RspaceStr25.ch.N
14935inline int algo::ch_N(const algo::RspaceStr25& parent) {
14936 u64 ret;
14937 ret = 25;
14938 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
14939 ret--;
14940 }
14941 return int(ret);
14942}
14943
14944// --- algo.RspaceStr25.ch.AssignStrptr
14945// Copy from strptr (operator=)
14946inline void algo::RspaceStr25::operator =(const algo::strptr &str) {
14947 ch_SetStrptr(*this, str);
14948}
14949
14950// --- algo.RspaceStr25.ch.Set
14951// Copy from same type
14952// Copy value from RHS.
14953inline void algo::RspaceStr25::operator =(const algo::RspaceStr25& parent) {
14954 memcpy(ch, parent.ch, 25);
14955}
14956
14957// --- algo.RspaceStr25.ch.Ctor
14958inline algo::RspaceStr25::RspaceStr25(const algo::RspaceStr25 &rhs) {
14959 operator =(rhs);
14960}
14961
14962// --- algo.RspaceStr25.ch.CtorStrptr
14963inline algo::RspaceStr25::RspaceStr25(const algo::strptr &rhs) {
14964 ch_SetStrptr(*this, rhs);
14965}
14966
14967// --- algo.RspaceStr25.ch.Cast
14968inline algo::RspaceStr25::operator algo::strptr () const {
14969 return ch_Getary(*this);
14970}
14971
14972// --- algo.RspaceStr25..Lt
14973inline bool algo::RspaceStr25_Lt(algo::RspaceStr25 lhs, algo::RspaceStr25 rhs) {
14974 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
14975}
14976
14977// --- algo.RspaceStr25..Cmp
14978inline i32 algo::RspaceStr25_Cmp(algo::RspaceStr25 lhs, algo::RspaceStr25 rhs) {
14979 i32 retval = 0;
14980 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
14981 return retval;
14982}
14983
14984// --- algo.RspaceStr25..Init
14985// Set all fields to initial values.
14986inline void algo::RspaceStr25_Init(algo::RspaceStr25& parent) {
14987 memset(parent.ch, ' ', 25);
14988}
14989
14990// --- algo.RspaceStr25..Eq
14991inline bool algo::RspaceStr25_Eq(algo::RspaceStr25 lhs, algo::RspaceStr25 rhs) {
14992 bool retval = true;
14993 retval = retval
14994 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
14995 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
14996 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
14997 &&*(u8*)(lhs.ch+24) == *(u8*)(rhs.ch+24);
14998 return retval;
14999}
15000
15001// --- algo.RspaceStr25..Update
15002// Set value. Return true if new value is different from old value.
15003inline bool algo::RspaceStr25_Update(algo::RspaceStr25 &lhs, algo::RspaceStr25 rhs) {
15004 bool ret = !RspaceStr25_Eq(lhs, rhs); // compare values
15005 if (ret) {
15006 lhs = rhs; // update
15007 }
15008 return ret;
15009}
15010
15011// --- algo.RspaceStr25..EqStrptr
15012inline bool algo::RspaceStr25_EqStrptr(algo::RspaceStr25 lhs, const algo::strptr& rhs) {
15013 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15014}
15015
15016inline bool algo::RspaceStr26::operator ==(const algo::RspaceStr26 &rhs) const {
15017 return algo::RspaceStr26_Eq(const_cast<algo::RspaceStr26&>(*this),const_cast<algo::RspaceStr26&>(rhs));
15018}
15019
15020inline bool algo::RspaceStr26::operator !=(const algo::RspaceStr26 &rhs) const {
15021 return !algo::RspaceStr26_Eq(const_cast<algo::RspaceStr26&>(*this),const_cast<algo::RspaceStr26&>(rhs));
15022}
15023
15024inline bool algo::RspaceStr26::operator ==(const algo::strptr &rhs) const {
15025 return algo::RspaceStr26_EqStrptr(const_cast<algo::RspaceStr26&>(*this),rhs);
15026}
15027inline algo::RspaceStr26::RspaceStr26() {
15028 algo::RspaceStr26_Init(*this);
15029}
15030
15031
15032// --- algo.RspaceStr26.ch.Getary
15033// Access string as array of chars
15034inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr26& parent) {
15035 int len = ch_N(parent);
15036 algo::aryptr<char> ret((char*)parent.ch, len);
15037 return ret;
15038}
15039
15040// --- algo.RspaceStr26.ch.HashStrptr
15041inline u32 algo::RspaceStr26_Hash(u32 prev, const algo::strptr &str) {
15042 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15043}
15044
15045// --- algo.RspaceStr26.ch.Init
15046inline void algo::ch_Init(algo::RspaceStr26 &parent) {
15047 memset(parent.ch, ' ', 26);
15048}
15049
15050// --- algo.RspaceStr26.ch.Max
15051// always return constant 26
15052inline int algo::ch_Max(algo::RspaceStr26& parent) {
15053 (void)parent;
15054 return 26;
15055}
15056
15057// --- algo.RspaceStr26.ch.N
15058inline int algo::ch_N(const algo::RspaceStr26& parent) {
15059 u64 ret;
15060 ret = 26;
15061 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15062 ret--;
15063 }
15064 return int(ret);
15065}
15066
15067// --- algo.RspaceStr26.ch.AssignStrptr
15068// Copy from strptr (operator=)
15069inline void algo::RspaceStr26::operator =(const algo::strptr &str) {
15070 ch_SetStrptr(*this, str);
15071}
15072
15073// --- algo.RspaceStr26.ch.Set
15074// Copy from same type
15075// Copy value from RHS.
15076inline void algo::RspaceStr26::operator =(const algo::RspaceStr26& parent) {
15077 memcpy(ch, parent.ch, 26);
15078}
15079
15080// --- algo.RspaceStr26.ch.Ctor
15081inline algo::RspaceStr26::RspaceStr26(const algo::RspaceStr26 &rhs) {
15082 operator =(rhs);
15083}
15084
15085// --- algo.RspaceStr26.ch.CtorStrptr
15086inline algo::RspaceStr26::RspaceStr26(const algo::strptr &rhs) {
15087 ch_SetStrptr(*this, rhs);
15088}
15089
15090// --- algo.RspaceStr26.ch.Cast
15091inline algo::RspaceStr26::operator algo::strptr () const {
15092 return ch_Getary(*this);
15093}
15094
15095// --- algo.RspaceStr26..Cmp
15096inline i32 algo::RspaceStr26_Cmp(algo::RspaceStr26& lhs, algo::RspaceStr26& rhs) {
15097 i32 retval = 0;
15098 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15099 return retval;
15100}
15101
15102// --- algo.RspaceStr26..Init
15103// Set all fields to initial values.
15104inline void algo::RspaceStr26_Init(algo::RspaceStr26& parent) {
15105 memset(parent.ch, ' ', 26);
15106}
15107
15108// --- algo.RspaceStr26..Eq
15109inline bool algo::RspaceStr26_Eq(algo::RspaceStr26& lhs, algo::RspaceStr26& rhs) {
15110 bool retval = true;
15111 retval = retval
15112 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15113 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15114 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15115 &&*(u16*)(lhs.ch+24) == *(u16*)(rhs.ch+24);
15116 return retval;
15117}
15118
15119// --- algo.RspaceStr26..EqStrptr
15120inline bool algo::RspaceStr26_EqStrptr(const algo::RspaceStr26& lhs, const algo::strptr& rhs) {
15121 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15122}
15123
15124inline bool algo::RspaceStr3::operator ==(const algo::RspaceStr3 &rhs) const {
15125 return algo::RspaceStr3_Eq(const_cast<algo::RspaceStr3&>(*this),const_cast<algo::RspaceStr3&>(rhs));
15126}
15127
15128inline bool algo::RspaceStr3::operator !=(const algo::RspaceStr3 &rhs) const {
15129 return !algo::RspaceStr3_Eq(const_cast<algo::RspaceStr3&>(*this),const_cast<algo::RspaceStr3&>(rhs));
15130}
15131
15132inline bool algo::RspaceStr3::operator ==(const algo::strptr &rhs) const {
15133 return algo::RspaceStr3_EqStrptr(const_cast<algo::RspaceStr3&>(*this),rhs);
15134}
15135inline algo::RspaceStr3::RspaceStr3() {
15136 algo::RspaceStr3_Init(*this);
15137}
15138
15139
15140// --- algo.RspaceStr3.ch.Getary
15141// Access string as array of chars
15142inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr3& parent) {
15143 int len = ch_N(parent);
15144 algo::aryptr<char> ret((char*)parent.ch, len);
15145 return ret;
15146}
15147
15148// --- algo.RspaceStr3.ch.HashStrptr
15149inline u32 algo::RspaceStr3_Hash(u32 prev, const algo::strptr &str) {
15150 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15151}
15152
15153// --- algo.RspaceStr3.ch.Init
15154inline void algo::ch_Init(algo::RspaceStr3 &parent) {
15155 memset(parent.ch, ' ', 3);
15156}
15157
15158// --- algo.RspaceStr3.ch.Max
15159// always return constant 3
15160inline int algo::ch_Max(algo::RspaceStr3& parent) {
15161 (void)parent;
15162 return 3;
15163}
15164
15165// --- algo.RspaceStr3.ch.N
15166inline int algo::ch_N(const algo::RspaceStr3& parent) {
15167 u64 ret;
15168 ret = 3;
15169 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15170 ret--;
15171 }
15172 return int(ret);
15173}
15174
15175// --- algo.RspaceStr3.ch.AssignStrptr
15176// Copy from strptr (operator=)
15177inline void algo::RspaceStr3::operator =(const algo::strptr &str) {
15178 ch_SetStrptr(*this, str);
15179}
15180
15181// --- algo.RspaceStr3.ch.Set
15182// Copy from same type
15183// Copy value from RHS.
15184inline void algo::RspaceStr3::operator =(const algo::RspaceStr3& parent) {
15185 memcpy(ch, parent.ch, 3);
15186}
15187
15188// --- algo.RspaceStr3.ch.Ctor
15189inline algo::RspaceStr3::RspaceStr3(const algo::RspaceStr3 &rhs) {
15190 operator =(rhs);
15191}
15192
15193// --- algo.RspaceStr3.ch.CtorStrptr
15194inline algo::RspaceStr3::RspaceStr3(const algo::strptr &rhs) {
15195 ch_SetStrptr(*this, rhs);
15196}
15197
15198// --- algo.RspaceStr3.ch.Cast
15199inline algo::RspaceStr3::operator algo::strptr () const {
15200 return ch_Getary(*this);
15201}
15202
15203// --- algo.RspaceStr3..Cmp
15204inline i32 algo::RspaceStr3_Cmp(algo::RspaceStr3 lhs, algo::RspaceStr3 rhs) {
15205 i32 retval = 0;
15206 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15207 return retval;
15208}
15209
15210// --- algo.RspaceStr3..Init
15211// Set all fields to initial values.
15212inline void algo::RspaceStr3_Init(algo::RspaceStr3& parent) {
15213 memset(parent.ch, ' ', 3);
15214}
15215
15216// --- algo.RspaceStr3..Eq
15217inline bool algo::RspaceStr3_Eq(algo::RspaceStr3 lhs, algo::RspaceStr3 rhs) {
15218 bool retval = true;
15219 retval = retval
15220 &&*(u16*)(lhs.ch+0) == *(u16*)(rhs.ch+0)
15221 &&*(u8*)(lhs.ch+2) == *(u8*)(rhs.ch+2);
15222 return retval;
15223}
15224
15225// --- algo.RspaceStr3..EqStrptr
15226inline bool algo::RspaceStr3_EqStrptr(algo::RspaceStr3 lhs, const algo::strptr& rhs) {
15227 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15228}
15229
15230inline bool algo::RspaceStr31::operator ==(const algo::RspaceStr31 &rhs) const {
15231 return algo::RspaceStr31_Eq(const_cast<algo::RspaceStr31&>(*this),const_cast<algo::RspaceStr31&>(rhs));
15232}
15233
15234inline bool algo::RspaceStr31::operator !=(const algo::RspaceStr31 &rhs) const {
15235 return !algo::RspaceStr31_Eq(const_cast<algo::RspaceStr31&>(*this),const_cast<algo::RspaceStr31&>(rhs));
15236}
15237
15238inline bool algo::RspaceStr31::operator ==(const algo::strptr &rhs) const {
15239 return algo::RspaceStr31_EqStrptr(const_cast<algo::RspaceStr31&>(*this),rhs);
15240}
15241inline algo::RspaceStr31::RspaceStr31() {
15242 algo::RspaceStr31_Init(*this);
15243}
15244
15245
15246// --- algo.RspaceStr31.ch.Getary
15247// Access string as array of chars
15248inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr31& parent) {
15249 int len = ch_N(parent);
15250 algo::aryptr<char> ret((char*)parent.ch, len);
15251 return ret;
15252}
15253
15254// --- algo.RspaceStr31.ch.HashStrptr
15255inline u32 algo::RspaceStr31_Hash(u32 prev, const algo::strptr &str) {
15256 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15257}
15258
15259// --- algo.RspaceStr31.ch.Init
15260inline void algo::ch_Init(algo::RspaceStr31 &parent) {
15261 memset(parent.ch, ' ', 31);
15262}
15263
15264// --- algo.RspaceStr31.ch.Max
15265// always return constant 31
15266inline int algo::ch_Max(algo::RspaceStr31& parent) {
15267 (void)parent;
15268 return 31;
15269}
15270
15271// --- algo.RspaceStr31.ch.N
15272inline int algo::ch_N(const algo::RspaceStr31& parent) {
15273 u64 ret;
15274 ret = 31;
15275 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15276 ret--;
15277 }
15278 return int(ret);
15279}
15280
15281// --- algo.RspaceStr31.ch.AssignStrptr
15282// Copy from strptr (operator=)
15283inline void algo::RspaceStr31::operator =(const algo::strptr &str) {
15284 ch_SetStrptr(*this, str);
15285}
15286
15287// --- algo.RspaceStr31.ch.Set
15288// Copy from same type
15289// Copy value from RHS.
15290inline void algo::RspaceStr31::operator =(const algo::RspaceStr31& parent) {
15291 memcpy(ch, parent.ch, 31);
15292}
15293
15294// --- algo.RspaceStr31.ch.Ctor
15295inline algo::RspaceStr31::RspaceStr31(const algo::RspaceStr31 &rhs) {
15296 operator =(rhs);
15297}
15298
15299// --- algo.RspaceStr31.ch.CtorStrptr
15300inline algo::RspaceStr31::RspaceStr31(const algo::strptr &rhs) {
15301 ch_SetStrptr(*this, rhs);
15302}
15303
15304// --- algo.RspaceStr31.ch.Cast
15305inline algo::RspaceStr31::operator algo::strptr () const {
15306 return ch_Getary(*this);
15307}
15308
15309// --- algo.RspaceStr31..Cmp
15310inline i32 algo::RspaceStr31_Cmp(algo::RspaceStr31& lhs, algo::RspaceStr31& rhs) {
15311 i32 retval = 0;
15312 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15313 return retval;
15314}
15315
15316// --- algo.RspaceStr31..Init
15317// Set all fields to initial values.
15318inline void algo::RspaceStr31_Init(algo::RspaceStr31& parent) {
15319 memset(parent.ch, ' ', 31);
15320}
15321
15322// --- algo.RspaceStr31..Eq
15323inline bool algo::RspaceStr31_Eq(algo::RspaceStr31& lhs, algo::RspaceStr31& rhs) {
15324 bool retval = true;
15325 retval = retval
15326 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15327 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15328 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15329 &&*(u32*)(lhs.ch+24) == *(u32*)(rhs.ch+24)
15330 &&*(u16*)(lhs.ch+28) == *(u16*)(rhs.ch+28)
15331 &&*(u8*)(lhs.ch+30) == *(u8*)(rhs.ch+30);
15332 return retval;
15333}
15334
15335// --- algo.RspaceStr31..EqStrptr
15336inline bool algo::RspaceStr31_EqStrptr(const algo::RspaceStr31& lhs, const algo::strptr& rhs) {
15337 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15338}
15339
15340inline bool algo::RspaceStr32::operator ==(const algo::RspaceStr32 &rhs) const {
15341 return algo::RspaceStr32_Eq(const_cast<algo::RspaceStr32&>(*this),const_cast<algo::RspaceStr32&>(rhs));
15342}
15343
15344inline bool algo::RspaceStr32::operator !=(const algo::RspaceStr32 &rhs) const {
15345 return !algo::RspaceStr32_Eq(const_cast<algo::RspaceStr32&>(*this),const_cast<algo::RspaceStr32&>(rhs));
15346}
15347
15348inline bool algo::RspaceStr32::operator ==(const algo::strptr &rhs) const {
15349 return algo::RspaceStr32_EqStrptr(const_cast<algo::RspaceStr32&>(*this),rhs);
15350}
15351inline algo::RspaceStr32::RspaceStr32() {
15352 algo::RspaceStr32_Init(*this);
15353}
15354
15355
15356// --- algo.RspaceStr32.ch.Getary
15357// Access string as array of chars
15358inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr32& parent) {
15359 int len = ch_N(parent);
15360 algo::aryptr<char> ret((char*)parent.ch, len);
15361 return ret;
15362}
15363
15364// --- algo.RspaceStr32.ch.HashStrptr
15365inline u32 algo::RspaceStr32_Hash(u32 prev, const algo::strptr &str) {
15366 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15367}
15368
15369// --- algo.RspaceStr32.ch.Init
15370inline void algo::ch_Init(algo::RspaceStr32 &parent) {
15371 memset(parent.ch, ' ', 32);
15372}
15373
15374// --- algo.RspaceStr32.ch.Max
15375// always return constant 32
15376inline int algo::ch_Max(algo::RspaceStr32& parent) {
15377 (void)parent;
15378 return 32;
15379}
15380
15381// --- algo.RspaceStr32.ch.N
15382inline int algo::ch_N(const algo::RspaceStr32& parent) {
15383 u64 ret;
15384 ret = 32;
15385 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15386 ret--;
15387 }
15388 return int(ret);
15389}
15390
15391// --- algo.RspaceStr32.ch.AssignStrptr
15392// Copy from strptr (operator=)
15393inline void algo::RspaceStr32::operator =(const algo::strptr &str) {
15394 ch_SetStrptr(*this, str);
15395}
15396
15397// --- algo.RspaceStr32.ch.Set
15398// Copy from same type
15399// Copy value from RHS.
15400inline void algo::RspaceStr32::operator =(const algo::RspaceStr32& parent) {
15401 memcpy(ch, parent.ch, 32);
15402}
15403
15404// --- algo.RspaceStr32.ch.Ctor
15405inline algo::RspaceStr32::RspaceStr32(const algo::RspaceStr32 &rhs) {
15406 operator =(rhs);
15407}
15408
15409// --- algo.RspaceStr32.ch.CtorStrptr
15410inline algo::RspaceStr32::RspaceStr32(const algo::strptr &rhs) {
15411 ch_SetStrptr(*this, rhs);
15412}
15413
15414// --- algo.RspaceStr32.ch.Cast
15415inline algo::RspaceStr32::operator algo::strptr () const {
15416 return ch_Getary(*this);
15417}
15418
15419// --- algo.RspaceStr32..Cmp
15420inline i32 algo::RspaceStr32_Cmp(algo::RspaceStr32 lhs, algo::RspaceStr32 rhs) {
15421 i32 retval = 0;
15422 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15423 return retval;
15424}
15425
15426// --- algo.RspaceStr32..Init
15427// Set all fields to initial values.
15428inline void algo::RspaceStr32_Init(algo::RspaceStr32& parent) {
15429 memset(parent.ch, ' ', 32);
15430}
15431
15432// --- algo.RspaceStr32..Eq
15433inline bool algo::RspaceStr32_Eq(algo::RspaceStr32 lhs, algo::RspaceStr32 rhs) {
15434 bool retval = true;
15435 retval = retval
15436 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15437 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15438 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15439 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24);
15440 return retval;
15441}
15442
15443// --- algo.RspaceStr32..EqStrptr
15444inline bool algo::RspaceStr32_EqStrptr(algo::RspaceStr32 lhs, const algo::strptr& rhs) {
15445 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15446}
15447
15448inline bool algo::RspaceStr4::operator ==(const algo::RspaceStr4 &rhs) const {
15449 return algo::RspaceStr4_Eq(const_cast<algo::RspaceStr4&>(*this),const_cast<algo::RspaceStr4&>(rhs));
15450}
15451
15452inline bool algo::RspaceStr4::operator !=(const algo::RspaceStr4 &rhs) const {
15453 return !algo::RspaceStr4_Eq(const_cast<algo::RspaceStr4&>(*this),const_cast<algo::RspaceStr4&>(rhs));
15454}
15455
15456inline bool algo::RspaceStr4::operator ==(const algo::strptr &rhs) const {
15457 return algo::RspaceStr4_EqStrptr(const_cast<algo::RspaceStr4&>(*this),rhs);
15458}
15459inline algo::RspaceStr4::RspaceStr4() {
15460 algo::RspaceStr4_Init(*this);
15461}
15462
15463
15464// --- algo.RspaceStr4.ch.Getary
15465// Access string as array of chars
15466inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr4& parent) {
15467 int len = ch_N(parent);
15468 algo::aryptr<char> ret((char*)parent.ch, len);
15469 return ret;
15470}
15471
15472// --- algo.RspaceStr4.ch.HashStrptr
15473inline u32 algo::RspaceStr4_Hash(u32 prev, const algo::strptr &str) {
15474 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15475}
15476
15477// --- algo.RspaceStr4.ch.Init
15478inline void algo::ch_Init(algo::RspaceStr4 &parent) {
15479 memset(parent.ch, ' ', 4);
15480}
15481
15482// --- algo.RspaceStr4.ch.Max
15483// always return constant 4
15484inline int algo::ch_Max(algo::RspaceStr4& parent) {
15485 (void)parent;
15486 return 4;
15487}
15488
15489// --- algo.RspaceStr4.ch.N
15490inline int algo::ch_N(const algo::RspaceStr4& parent) {
15491 u64 ret;
15492 ret = 4;
15493 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15494 ret--;
15495 }
15496 return int(ret);
15497}
15498
15499// --- algo.RspaceStr4.ch.AssignStrptr
15500// Copy from strptr (operator=)
15501inline void algo::RspaceStr4::operator =(const algo::strptr &str) {
15502 ch_SetStrptr(*this, str);
15503}
15504
15505// --- algo.RspaceStr4.ch.Set
15506// Copy from same type
15507// Copy value from RHS.
15508inline void algo::RspaceStr4::operator =(const algo::RspaceStr4& parent) {
15509 memcpy(ch, parent.ch, 4);
15510}
15511
15512// --- algo.RspaceStr4.ch.Ctor
15513inline algo::RspaceStr4::RspaceStr4(const algo::RspaceStr4 &rhs) {
15514 operator =(rhs);
15515}
15516
15517// --- algo.RspaceStr4.ch.CtorStrptr
15518inline algo::RspaceStr4::RspaceStr4(const algo::strptr &rhs) {
15519 ch_SetStrptr(*this, rhs);
15520}
15521
15522// --- algo.RspaceStr4.ch.Cast
15523inline algo::RspaceStr4::operator algo::strptr () const {
15524 return ch_Getary(*this);
15525}
15526
15527// --- algo.RspaceStr4..Cmp
15528inline i32 algo::RspaceStr4_Cmp(algo::RspaceStr4 lhs, algo::RspaceStr4 rhs) {
15529 i32 retval = 0;
15530 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15531 return retval;
15532}
15533
15534// --- algo.RspaceStr4..Init
15535// Set all fields to initial values.
15536inline void algo::RspaceStr4_Init(algo::RspaceStr4& parent) {
15537 memset(parent.ch, ' ', 4);
15538}
15539
15540// --- algo.RspaceStr4..Eq
15541inline bool algo::RspaceStr4_Eq(algo::RspaceStr4 lhs, algo::RspaceStr4 rhs) {
15542 bool retval = true;
15543 retval = retval
15544 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0);
15545 return retval;
15546}
15547
15548// --- algo.RspaceStr4..EqStrptr
15549inline bool algo::RspaceStr4_EqStrptr(algo::RspaceStr4 lhs, const algo::strptr& rhs) {
15550 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15551}
15552inline algo::RspaceStr40::RspaceStr40() {
15553 algo::RspaceStr40_Init(*this);
15554}
15555
15556
15557// --- algo.RspaceStr40.ch.Getary
15558// Access string as array of chars
15559inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr40& parent) {
15560 int len = ch_N(parent);
15561 algo::aryptr<char> ret((char*)parent.ch, len);
15562 return ret;
15563}
15564
15565// --- algo.RspaceStr40.ch.HashStrptr
15566inline u32 algo::RspaceStr40_Hash(u32 prev, const algo::strptr &str) {
15567 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15568}
15569
15570// --- algo.RspaceStr40.ch.Init
15571inline void algo::ch_Init(algo::RspaceStr40 &parent) {
15572 memset(parent.ch, ' ', 40);
15573}
15574
15575// --- algo.RspaceStr40.ch.Max
15576// always return constant 40
15577inline int algo::ch_Max(algo::RspaceStr40& parent) {
15578 (void)parent;
15579 return 40;
15580}
15581
15582// --- algo.RspaceStr40.ch.N
15583inline int algo::ch_N(const algo::RspaceStr40& parent) {
15584 u64 ret;
15585 ret = 40;
15586 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15587 ret--;
15588 }
15589 return int(ret);
15590}
15591
15592// --- algo.RspaceStr40.ch.AssignStrptr
15593// Copy from strptr (operator=)
15594inline void algo::RspaceStr40::operator =(const algo::strptr &str) {
15595 ch_SetStrptr(*this, str);
15596}
15597
15598// --- algo.RspaceStr40.ch.Set
15599// Copy from same type
15600// Copy value from RHS.
15601inline void algo::RspaceStr40::operator =(const algo::RspaceStr40& parent) {
15602 memcpy(ch, parent.ch, 40);
15603}
15604
15605// --- algo.RspaceStr40.ch.Ctor
15606inline algo::RspaceStr40::RspaceStr40(const algo::RspaceStr40 &rhs) {
15607 operator =(rhs);
15608}
15609
15610// --- algo.RspaceStr40.ch.CtorStrptr
15611inline algo::RspaceStr40::RspaceStr40(const algo::strptr &rhs) {
15612 ch_SetStrptr(*this, rhs);
15613}
15614
15615// --- algo.RspaceStr40.ch.Cast
15616inline algo::RspaceStr40::operator algo::strptr () const {
15617 return ch_Getary(*this);
15618}
15619
15620// --- algo.RspaceStr40..Cmp
15621inline i32 algo::RspaceStr40_Cmp(algo::RspaceStr40 lhs, algo::RspaceStr40 rhs) {
15622 i32 retval = 0;
15623 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15624 return retval;
15625}
15626
15627// --- algo.RspaceStr40..Init
15628// Set all fields to initial values.
15629inline void algo::RspaceStr40_Init(algo::RspaceStr40& parent) {
15630 memset(parent.ch, ' ', 40);
15631}
15632
15633// --- algo.RspaceStr40..Eq
15634inline bool algo::RspaceStr40_Eq(algo::RspaceStr40 lhs, algo::RspaceStr40 rhs) {
15635 bool retval = true;
15636 retval = retval
15637 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15638 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15639 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15640 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
15641 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32);
15642 return retval;
15643}
15644
15645// --- algo.RspaceStr40..EqStrptr
15646inline bool algo::RspaceStr40_EqStrptr(algo::RspaceStr40 lhs, const algo::strptr& rhs) {
15647 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15648}
15649
15650inline bool algo::RspaceStr5::operator ==(const algo::RspaceStr5 &rhs) const {
15651 return algo::RspaceStr5_Eq(const_cast<algo::RspaceStr5&>(*this),const_cast<algo::RspaceStr5&>(rhs));
15652}
15653
15654inline bool algo::RspaceStr5::operator !=(const algo::RspaceStr5 &rhs) const {
15655 return !algo::RspaceStr5_Eq(const_cast<algo::RspaceStr5&>(*this),const_cast<algo::RspaceStr5&>(rhs));
15656}
15657
15658inline bool algo::RspaceStr5::operator ==(const algo::strptr &rhs) const {
15659 return algo::RspaceStr5_EqStrptr(const_cast<algo::RspaceStr5&>(*this),rhs);
15660}
15661inline algo::RspaceStr5::RspaceStr5() {
15662 algo::RspaceStr5_Init(*this);
15663}
15664
15665
15666// --- algo.RspaceStr5.ch.Getary
15667// Access string as array of chars
15668inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr5& parent) {
15669 int len = ch_N(parent);
15670 algo::aryptr<char> ret((char*)parent.ch, len);
15671 return ret;
15672}
15673
15674// --- algo.RspaceStr5.ch.HashStrptr
15675inline u32 algo::RspaceStr5_Hash(u32 prev, const algo::strptr &str) {
15676 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15677}
15678
15679// --- algo.RspaceStr5.ch.Init
15680inline void algo::ch_Init(algo::RspaceStr5 &parent) {
15681 memset(parent.ch, ' ', 5);
15682}
15683
15684// --- algo.RspaceStr5.ch.Max
15685// always return constant 5
15686inline int algo::ch_Max(algo::RspaceStr5& parent) {
15687 (void)parent;
15688 return 5;
15689}
15690
15691// --- algo.RspaceStr5.ch.N
15692inline int algo::ch_N(const algo::RspaceStr5& parent) {
15693 u64 ret;
15694 ret = 5;
15695 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15696 ret--;
15697 }
15698 return int(ret);
15699}
15700
15701// --- algo.RspaceStr5.ch.AssignStrptr
15702// Copy from strptr (operator=)
15703inline void algo::RspaceStr5::operator =(const algo::strptr &str) {
15704 ch_SetStrptr(*this, str);
15705}
15706
15707// --- algo.RspaceStr5.ch.Set
15708// Copy from same type
15709// Copy value from RHS.
15710inline void algo::RspaceStr5::operator =(const algo::RspaceStr5& parent) {
15711 memcpy(ch, parent.ch, 5);
15712}
15713
15714// --- algo.RspaceStr5.ch.Ctor
15715inline algo::RspaceStr5::RspaceStr5(const algo::RspaceStr5 &rhs) {
15716 operator =(rhs);
15717}
15718
15719// --- algo.RspaceStr5.ch.CtorStrptr
15720inline algo::RspaceStr5::RspaceStr5(const algo::strptr &rhs) {
15721 ch_SetStrptr(*this, rhs);
15722}
15723
15724// --- algo.RspaceStr5.ch.Cast
15725inline algo::RspaceStr5::operator algo::strptr () const {
15726 return ch_Getary(*this);
15727}
15728
15729// --- algo.RspaceStr5..Cmp
15730inline i32 algo::RspaceStr5_Cmp(algo::RspaceStr5 lhs, algo::RspaceStr5 rhs) {
15731 i32 retval = 0;
15732 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15733 return retval;
15734}
15735
15736// --- algo.RspaceStr5..Init
15737// Set all fields to initial values.
15738inline void algo::RspaceStr5_Init(algo::RspaceStr5& parent) {
15739 memset(parent.ch, ' ', 5);
15740}
15741
15742// --- algo.RspaceStr5..Eq
15743inline bool algo::RspaceStr5_Eq(algo::RspaceStr5 lhs, algo::RspaceStr5 rhs) {
15744 bool retval = true;
15745 retval = retval
15746 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
15747 &&*(u8*)(lhs.ch+4) == *(u8*)(rhs.ch+4);
15748 return retval;
15749}
15750
15751// --- algo.RspaceStr5..EqStrptr
15752inline bool algo::RspaceStr5_EqStrptr(algo::RspaceStr5 lhs, const algo::strptr& rhs) {
15753 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15754}
15755
15756inline bool algo::RspaceStr50::operator ==(const algo::RspaceStr50 &rhs) const {
15757 return algo::RspaceStr50_Eq(const_cast<algo::RspaceStr50&>(*this),const_cast<algo::RspaceStr50&>(rhs));
15758}
15759
15760inline bool algo::RspaceStr50::operator !=(const algo::RspaceStr50 &rhs) const {
15761 return !algo::RspaceStr50_Eq(const_cast<algo::RspaceStr50&>(*this),const_cast<algo::RspaceStr50&>(rhs));
15762}
15763
15764inline bool algo::RspaceStr50::operator ==(const algo::strptr &rhs) const {
15765 return algo::RspaceStr50_EqStrptr(const_cast<algo::RspaceStr50&>(*this),rhs);
15766}
15767inline algo::RspaceStr50::RspaceStr50() {
15768 algo::RspaceStr50_Init(*this);
15769}
15770
15771
15772// --- algo.RspaceStr50.ch.Getary
15773// Access string as array of chars
15774inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr50& parent) {
15775 int len = ch_N(parent);
15776 algo::aryptr<char> ret((char*)parent.ch, len);
15777 return ret;
15778}
15779
15780// --- algo.RspaceStr50.ch.HashStrptr
15781inline u32 algo::RspaceStr50_Hash(u32 prev, const algo::strptr &str) {
15782 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15783}
15784
15785// --- algo.RspaceStr50.ch.Init
15786inline void algo::ch_Init(algo::RspaceStr50 &parent) {
15787 memset(parent.ch, ' ', 50);
15788}
15789
15790// --- algo.RspaceStr50.ch.Max
15791// always return constant 50
15792inline int algo::ch_Max(algo::RspaceStr50& parent) {
15793 (void)parent;
15794 return 50;
15795}
15796
15797// --- algo.RspaceStr50.ch.N
15798inline int algo::ch_N(const algo::RspaceStr50& parent) {
15799 u64 ret;
15800 ret = 50;
15801 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15802 ret--;
15803 }
15804 return int(ret);
15805}
15806
15807// --- algo.RspaceStr50.ch.AssignStrptr
15808// Copy from strptr (operator=)
15809inline void algo::RspaceStr50::operator =(const algo::strptr &str) {
15810 ch_SetStrptr(*this, str);
15811}
15812
15813// --- algo.RspaceStr50.ch.Set
15814// Copy from same type
15815// Copy value from RHS.
15816inline void algo::RspaceStr50::operator =(const algo::RspaceStr50& parent) {
15817 memcpy(ch, parent.ch, 50);
15818}
15819
15820// --- algo.RspaceStr50.ch.Ctor
15821inline algo::RspaceStr50::RspaceStr50(const algo::RspaceStr50 &rhs) {
15822 operator =(rhs);
15823}
15824
15825// --- algo.RspaceStr50.ch.CtorStrptr
15826inline algo::RspaceStr50::RspaceStr50(const algo::strptr &rhs) {
15827 ch_SetStrptr(*this, rhs);
15828}
15829
15830// --- algo.RspaceStr50.ch.Cast
15831inline algo::RspaceStr50::operator algo::strptr () const {
15832 return ch_Getary(*this);
15833}
15834
15835// --- algo.RspaceStr50..Cmp
15836inline i32 algo::RspaceStr50_Cmp(algo::RspaceStr50 lhs, algo::RspaceStr50 rhs) {
15837 i32 retval = 0;
15838 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15839 return retval;
15840}
15841
15842// --- algo.RspaceStr50..Init
15843// Set all fields to initial values.
15844inline void algo::RspaceStr50_Init(algo::RspaceStr50& parent) {
15845 memset(parent.ch, ' ', 50);
15846}
15847
15848// --- algo.RspaceStr50..Eq
15849inline bool algo::RspaceStr50_Eq(algo::RspaceStr50 lhs, algo::RspaceStr50 rhs) {
15850 bool retval = true;
15851 retval = retval
15852 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
15853 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
15854 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
15855 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
15856 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
15857 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
15858 &&*(u16*)(lhs.ch+48) == *(u16*)(rhs.ch+48);
15859 return retval;
15860}
15861
15862// --- algo.RspaceStr50..EqStrptr
15863inline bool algo::RspaceStr50_EqStrptr(algo::RspaceStr50 lhs, const algo::strptr& rhs) {
15864 return algo::strptr_Eq(ch_Getary(lhs), rhs);
15865}
15866
15867inline bool algo::RspaceStr6::operator ==(const algo::RspaceStr6 &rhs) const {
15868 return algo::RspaceStr6_Eq(const_cast<algo::RspaceStr6&>(*this),const_cast<algo::RspaceStr6&>(rhs));
15869}
15870
15871inline bool algo::RspaceStr6::operator !=(const algo::RspaceStr6 &rhs) const {
15872 return !algo::RspaceStr6_Eq(const_cast<algo::RspaceStr6&>(*this),const_cast<algo::RspaceStr6&>(rhs));
15873}
15874
15875inline bool algo::RspaceStr6::operator ==(const algo::strptr &rhs) const {
15876 return algo::RspaceStr6_EqStrptr(const_cast<algo::RspaceStr6&>(*this),rhs);
15877}
15878
15879inline bool algo::RspaceStr6::operator <(const algo::RspaceStr6 &rhs) const {
15880 return algo::RspaceStr6_Lt(const_cast<algo::RspaceStr6&>(*this),const_cast<algo::RspaceStr6&>(rhs));
15881}
15882
15883inline bool algo::RspaceStr6::operator >(const algo::RspaceStr6 &rhs) const {
15884 return rhs < *this;
15885}
15886
15887inline bool algo::RspaceStr6::operator <=(const algo::RspaceStr6 &rhs) const {
15888 return !(rhs < *this);
15889}
15890
15891inline bool algo::RspaceStr6::operator >=(const algo::RspaceStr6 &rhs) const {
15892 return !(*this < rhs);
15893}
15894inline algo::RspaceStr6::RspaceStr6() {
15895 algo::RspaceStr6_Init(*this);
15896}
15897
15898
15899// --- algo.RspaceStr6.ch.Getary
15900// Access string as array of chars
15901inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr6& parent) {
15902 int len = ch_N(parent);
15903 algo::aryptr<char> ret((char*)parent.ch, len);
15904 return ret;
15905}
15906
15907// --- algo.RspaceStr6.ch.HashStrptr
15908inline u32 algo::RspaceStr6_Hash(u32 prev, const algo::strptr &str) {
15909 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
15910}
15911
15912// --- algo.RspaceStr6.ch.Init
15913inline void algo::ch_Init(algo::RspaceStr6 &parent) {
15914 memset(parent.ch, ' ', 6);
15915}
15916
15917// --- algo.RspaceStr6.ch.Max
15918// always return constant 6
15919inline int algo::ch_Max(algo::RspaceStr6& parent) {
15920 (void)parent;
15921 return 6;
15922}
15923
15924// --- algo.RspaceStr6.ch.N
15925inline int algo::ch_N(const algo::RspaceStr6& parent) {
15926 u64 ret;
15927 ret = 6;
15928 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
15929 ret--;
15930 }
15931 return int(ret);
15932}
15933
15934// --- algo.RspaceStr6.ch.AssignStrptr
15935// Copy from strptr (operator=)
15936inline void algo::RspaceStr6::operator =(const algo::strptr &str) {
15937 ch_SetStrptr(*this, str);
15938}
15939
15940// --- algo.RspaceStr6.ch.Set
15941// Copy from same type
15942// Copy value from RHS.
15943inline void algo::RspaceStr6::operator =(const algo::RspaceStr6& parent) {
15944 memcpy(ch, parent.ch, 6);
15945}
15946
15947// --- algo.RspaceStr6.ch.Ctor
15948inline algo::RspaceStr6::RspaceStr6(const algo::RspaceStr6 &rhs) {
15949 operator =(rhs);
15950}
15951
15952// --- algo.RspaceStr6.ch.CtorStrptr
15953inline algo::RspaceStr6::RspaceStr6(const algo::strptr &rhs) {
15954 ch_SetStrptr(*this, rhs);
15955}
15956
15957// --- algo.RspaceStr6.ch.Cast
15958inline algo::RspaceStr6::operator algo::strptr () const {
15959 return ch_Getary(*this);
15960}
15961
15962// --- algo.RspaceStr6..Lt
15963inline bool algo::RspaceStr6_Lt(algo::RspaceStr6 lhs, algo::RspaceStr6 rhs) {
15964 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
15965}
15966
15967// --- algo.RspaceStr6..Cmp
15968inline i32 algo::RspaceStr6_Cmp(algo::RspaceStr6 lhs, algo::RspaceStr6 rhs) {
15969 i32 retval = 0;
15970 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
15971 return retval;
15972}
15973
15974// --- algo.RspaceStr6..Init
15975// Set all fields to initial values.
15976inline void algo::RspaceStr6_Init(algo::RspaceStr6& parent) {
15977 memset(parent.ch, ' ', 6);
15978}
15979
15980// --- algo.RspaceStr6..Eq
15981inline bool algo::RspaceStr6_Eq(algo::RspaceStr6 lhs, algo::RspaceStr6 rhs) {
15982 bool retval = true;
15983 retval = retval
15984 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
15985 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4);
15986 return retval;
15987}
15988
15989// --- algo.RspaceStr6..Update
15990// Set value. Return true if new value is different from old value.
15991inline bool algo::RspaceStr6_Update(algo::RspaceStr6 &lhs, algo::RspaceStr6 rhs) {
15992 bool ret = !RspaceStr6_Eq(lhs, rhs); // compare values
15993 if (ret) {
15994 lhs = rhs; // update
15995 }
15996 return ret;
15997}
15998
15999// --- algo.RspaceStr6..EqStrptr
16000inline bool algo::RspaceStr6_EqStrptr(algo::RspaceStr6 lhs, const algo::strptr& rhs) {
16001 return algo::strptr_Eq(ch_Getary(lhs), rhs);
16002}
16003
16004inline bool algo::RspaceStr64::operator ==(const algo::RspaceStr64 &rhs) const {
16005 return algo::RspaceStr64_Eq(const_cast<algo::RspaceStr64&>(*this),const_cast<algo::RspaceStr64&>(rhs));
16006}
16007
16008inline bool algo::RspaceStr64::operator !=(const algo::RspaceStr64 &rhs) const {
16009 return !algo::RspaceStr64_Eq(const_cast<algo::RspaceStr64&>(*this),const_cast<algo::RspaceStr64&>(rhs));
16010}
16011
16012inline bool algo::RspaceStr64::operator ==(const algo::strptr &rhs) const {
16013 return algo::RspaceStr64_EqStrptr(const_cast<algo::RspaceStr64&>(*this),rhs);
16014}
16015inline algo::RspaceStr64::RspaceStr64() {
16016 algo::RspaceStr64_Init(*this);
16017}
16018
16019
16020// --- algo.RspaceStr64.ch.Getary
16021// Access string as array of chars
16022inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr64& parent) {
16023 int len = ch_N(parent);
16024 algo::aryptr<char> ret((char*)parent.ch, len);
16025 return ret;
16026}
16027
16028// --- algo.RspaceStr64.ch.HashStrptr
16029inline u32 algo::RspaceStr64_Hash(u32 prev, const algo::strptr &str) {
16030 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16031}
16032
16033// --- algo.RspaceStr64.ch.Init
16034inline void algo::ch_Init(algo::RspaceStr64 &parent) {
16035 memset(parent.ch, ' ', 64);
16036}
16037
16038// --- algo.RspaceStr64.ch.Max
16039// always return constant 64
16040inline int algo::ch_Max(algo::RspaceStr64& parent) {
16041 (void)parent;
16042 return 64;
16043}
16044
16045// --- algo.RspaceStr64.ch.N
16046inline int algo::ch_N(const algo::RspaceStr64& parent) {
16047 u64 ret;
16048 ret = 64;
16049 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16050 ret--;
16051 }
16052 return int(ret);
16053}
16054
16055// --- algo.RspaceStr64.ch.AssignStrptr
16056// Copy from strptr (operator=)
16057inline void algo::RspaceStr64::operator =(const algo::strptr &str) {
16058 ch_SetStrptr(*this, str);
16059}
16060
16061// --- algo.RspaceStr64.ch.Set
16062// Copy from same type
16063// Copy value from RHS.
16064inline void algo::RspaceStr64::operator =(const algo::RspaceStr64& parent) {
16065 memcpy(ch, parent.ch, 64);
16066}
16067
16068// --- algo.RspaceStr64.ch.Ctor
16069inline algo::RspaceStr64::RspaceStr64(const algo::RspaceStr64 &rhs) {
16070 operator =(rhs);
16071}
16072
16073// --- algo.RspaceStr64.ch.CtorStrptr
16074inline algo::RspaceStr64::RspaceStr64(const algo::strptr &rhs) {
16075 ch_SetStrptr(*this, rhs);
16076}
16077
16078// --- algo.RspaceStr64.ch.Cast
16079inline algo::RspaceStr64::operator algo::strptr () const {
16080 return ch_Getary(*this);
16081}
16082
16083// --- algo.RspaceStr64..Cmp
16084inline i32 algo::RspaceStr64_Cmp(algo::RspaceStr64& lhs, algo::RspaceStr64& rhs) {
16085 i32 retval = 0;
16086 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16087 return retval;
16088}
16089
16090// --- algo.RspaceStr64..Init
16091// Set all fields to initial values.
16092inline void algo::RspaceStr64_Init(algo::RspaceStr64& parent) {
16093 memset(parent.ch, ' ', 64);
16094}
16095
16096// --- algo.RspaceStr64..Eq
16097inline bool algo::RspaceStr64_Eq(algo::RspaceStr64& lhs, algo::RspaceStr64& rhs) {
16098 bool retval = true;
16099 retval = retval
16100 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
16101 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
16102 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
16103 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
16104 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
16105 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
16106 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
16107 &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56);
16108 return retval;
16109}
16110
16111// --- algo.RspaceStr64..EqStrptr
16112inline bool algo::RspaceStr64_EqStrptr(const algo::RspaceStr64& lhs, const algo::strptr& rhs) {
16113 return algo::strptr_Eq(ch_Getary(lhs), rhs);
16114}
16115
16116inline bool algo::RspaceStr7::operator ==(const algo::RspaceStr7 &rhs) const {
16117 return algo::RspaceStr7_Eq(const_cast<algo::RspaceStr7&>(*this),const_cast<algo::RspaceStr7&>(rhs));
16118}
16119
16120inline bool algo::RspaceStr7::operator !=(const algo::RspaceStr7 &rhs) const {
16121 return !algo::RspaceStr7_Eq(const_cast<algo::RspaceStr7&>(*this),const_cast<algo::RspaceStr7&>(rhs));
16122}
16123
16124inline bool algo::RspaceStr7::operator ==(const algo::strptr &rhs) const {
16125 return algo::RspaceStr7_EqStrptr(const_cast<algo::RspaceStr7&>(*this),rhs);
16126}
16127inline algo::RspaceStr7::RspaceStr7() {
16128 algo::RspaceStr7_Init(*this);
16129}
16130
16131
16132// --- algo.RspaceStr7.ch.Getary
16133// Access string as array of chars
16134inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr7& parent) {
16135 int len = ch_N(parent);
16136 algo::aryptr<char> ret((char*)parent.ch, len);
16137 return ret;
16138}
16139
16140// --- algo.RspaceStr7.ch.HashStrptr
16141inline u32 algo::RspaceStr7_Hash(u32 prev, const algo::strptr &str) {
16142 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16143}
16144
16145// --- algo.RspaceStr7.ch.Init
16146inline void algo::ch_Init(algo::RspaceStr7 &parent) {
16147 memset(parent.ch, ' ', 7);
16148}
16149
16150// --- algo.RspaceStr7.ch.Max
16151// always return constant 7
16152inline int algo::ch_Max(algo::RspaceStr7& parent) {
16153 (void)parent;
16154 return 7;
16155}
16156
16157// --- algo.RspaceStr7.ch.N
16158inline int algo::ch_N(const algo::RspaceStr7& parent) {
16159 u64 ret;
16160 ret = 7;
16161 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16162 ret--;
16163 }
16164 return int(ret);
16165}
16166
16167// --- algo.RspaceStr7.ch.AssignStrptr
16168// Copy from strptr (operator=)
16169inline void algo::RspaceStr7::operator =(const algo::strptr &str) {
16170 ch_SetStrptr(*this, str);
16171}
16172
16173// --- algo.RspaceStr7.ch.Set
16174// Copy from same type
16175// Copy value from RHS.
16176inline void algo::RspaceStr7::operator =(const algo::RspaceStr7& parent) {
16177 memcpy(ch, parent.ch, 7);
16178}
16179
16180// --- algo.RspaceStr7.ch.Ctor
16181inline algo::RspaceStr7::RspaceStr7(const algo::RspaceStr7 &rhs) {
16182 operator =(rhs);
16183}
16184
16185// --- algo.RspaceStr7.ch.CtorStrptr
16186inline algo::RspaceStr7::RspaceStr7(const algo::strptr &rhs) {
16187 ch_SetStrptr(*this, rhs);
16188}
16189
16190// --- algo.RspaceStr7.ch.Cast
16191inline algo::RspaceStr7::operator algo::strptr () const {
16192 return ch_Getary(*this);
16193}
16194
16195// --- algo.RspaceStr7..Cmp
16196inline i32 algo::RspaceStr7_Cmp(algo::RspaceStr7 lhs, algo::RspaceStr7 rhs) {
16197 i32 retval = 0;
16198 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16199 return retval;
16200}
16201
16202// --- algo.RspaceStr7..Init
16203// Set all fields to initial values.
16204inline void algo::RspaceStr7_Init(algo::RspaceStr7& parent) {
16205 memset(parent.ch, ' ', 7);
16206}
16207
16208// --- algo.RspaceStr7..Eq
16209inline bool algo::RspaceStr7_Eq(algo::RspaceStr7 lhs, algo::RspaceStr7 rhs) {
16210 bool retval = true;
16211 retval = retval
16212 &&*(u32*)(lhs.ch+0) == *(u32*)(rhs.ch+0)
16213 &&*(u16*)(lhs.ch+4) == *(u16*)(rhs.ch+4)
16214 &&*(u8*)(lhs.ch+6) == *(u8*)(rhs.ch+6);
16215 return retval;
16216}
16217
16218// --- algo.RspaceStr7..EqStrptr
16219inline bool algo::RspaceStr7_EqStrptr(algo::RspaceStr7 lhs, const algo::strptr& rhs) {
16220 return algo::strptr_Eq(ch_Getary(lhs), rhs);
16221}
16222
16223inline bool algo::RspaceStr75::operator ==(const algo::RspaceStr75 &rhs) const {
16224 return algo::RspaceStr75_Eq(const_cast<algo::RspaceStr75&>(*this),const_cast<algo::RspaceStr75&>(rhs));
16225}
16226
16227inline bool algo::RspaceStr75::operator !=(const algo::RspaceStr75 &rhs) const {
16228 return !algo::RspaceStr75_Eq(const_cast<algo::RspaceStr75&>(*this),const_cast<algo::RspaceStr75&>(rhs));
16229}
16230
16231inline bool algo::RspaceStr75::operator ==(const algo::strptr &rhs) const {
16232 return algo::RspaceStr75_EqStrptr(const_cast<algo::RspaceStr75&>(*this),rhs);
16233}
16234inline algo::RspaceStr75::RspaceStr75() {
16235 algo::RspaceStr75_Init(*this);
16236}
16237
16238
16239// --- algo.RspaceStr75.ch.Getary
16240// Access string as array of chars
16241inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr75& parent) {
16242 int len = ch_N(parent);
16243 algo::aryptr<char> ret((char*)parent.ch, len);
16244 return ret;
16245}
16246
16247// --- algo.RspaceStr75.ch.HashStrptr
16248inline u32 algo::RspaceStr75_Hash(u32 prev, const algo::strptr &str) {
16249 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16250}
16251
16252// --- algo.RspaceStr75.ch.Init
16253inline void algo::ch_Init(algo::RspaceStr75 &parent) {
16254 memset(parent.ch, ' ', 75);
16255}
16256
16257// --- algo.RspaceStr75.ch.Max
16258// always return constant 75
16259inline int algo::ch_Max(algo::RspaceStr75& parent) {
16260 (void)parent;
16261 return 75;
16262}
16263
16264// --- algo.RspaceStr75.ch.N
16265inline int algo::ch_N(const algo::RspaceStr75& parent) {
16266 u64 ret;
16267 ret = 75;
16268 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16269 ret--;
16270 }
16271 return int(ret);
16272}
16273
16274// --- algo.RspaceStr75.ch.AssignStrptr
16275// Copy from strptr (operator=)
16276inline void algo::RspaceStr75::operator =(const algo::strptr &str) {
16277 ch_SetStrptr(*this, str);
16278}
16279
16280// --- algo.RspaceStr75.ch.Set
16281// Copy from same type
16282// Copy value from RHS.
16283inline void algo::RspaceStr75::operator =(const algo::RspaceStr75& parent) {
16284 memcpy(ch, parent.ch, 75);
16285}
16286
16287// --- algo.RspaceStr75.ch.Ctor
16288inline algo::RspaceStr75::RspaceStr75(const algo::RspaceStr75 &rhs) {
16289 operator =(rhs);
16290}
16291
16292// --- algo.RspaceStr75.ch.CtorStrptr
16293inline algo::RspaceStr75::RspaceStr75(const algo::strptr &rhs) {
16294 ch_SetStrptr(*this, rhs);
16295}
16296
16297// --- algo.RspaceStr75.ch.Cast
16298inline algo::RspaceStr75::operator algo::strptr () const {
16299 return ch_Getary(*this);
16300}
16301
16302// --- algo.RspaceStr75..Cmp
16303inline i32 algo::RspaceStr75_Cmp(algo::RspaceStr75 lhs, algo::RspaceStr75 rhs) {
16304 i32 retval = 0;
16305 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16306 return retval;
16307}
16308
16309// --- algo.RspaceStr75..Init
16310// Set all fields to initial values.
16311inline void algo::RspaceStr75_Init(algo::RspaceStr75& parent) {
16312 memset(parent.ch, ' ', 75);
16313}
16314
16315// --- algo.RspaceStr75..Eq
16316inline bool algo::RspaceStr75_Eq(algo::RspaceStr75 lhs, algo::RspaceStr75 rhs) {
16317 bool retval = true;
16318 retval = retval
16319 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
16320 &&*(u64*)(lhs.ch+8) == *(u64*)(rhs.ch+8)
16321 &&*(u64*)(lhs.ch+16) == *(u64*)(rhs.ch+16)
16322 &&*(u64*)(lhs.ch+24) == *(u64*)(rhs.ch+24)
16323 &&*(u64*)(lhs.ch+32) == *(u64*)(rhs.ch+32)
16324 &&*(u64*)(lhs.ch+40) == *(u64*)(rhs.ch+40)
16325 &&*(u64*)(lhs.ch+48) == *(u64*)(rhs.ch+48)
16326 &&*(u64*)(lhs.ch+56) == *(u64*)(rhs.ch+56)
16327 &&*(u64*)(lhs.ch+64) == *(u64*)(rhs.ch+64)
16328 &&*(u16*)(lhs.ch+72) == *(u16*)(rhs.ch+72)
16329 &&*(u8*)(lhs.ch+74) == *(u8*)(rhs.ch+74);
16330 return retval;
16331}
16332
16333// --- algo.RspaceStr75..EqStrptr
16334inline bool algo::RspaceStr75_EqStrptr(algo::RspaceStr75 lhs, const algo::strptr& rhs) {
16335 return algo::strptr_Eq(ch_Getary(lhs), rhs);
16336}
16337inline algo::RspaceStr8::RspaceStr8() {
16338 algo::RspaceStr8_Init(*this);
16339}
16340
16341
16342// --- algo.RspaceStr8.ch.Getary
16343// Access string as array of chars
16344inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr8& parent) {
16345 int len = ch_N(parent);
16346 algo::aryptr<char> ret((char*)parent.ch, len);
16347 return ret;
16348}
16349
16350// --- algo.RspaceStr8.ch.HashStrptr
16351inline u32 algo::RspaceStr8_Hash(u32 prev, const algo::strptr &str) {
16352 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16353}
16354
16355// --- algo.RspaceStr8.ch.Init
16356inline void algo::ch_Init(algo::RspaceStr8 &parent) {
16357 memset(parent.ch, ' ', 8);
16358}
16359
16360// --- algo.RspaceStr8.ch.Max
16361// always return constant 8
16362inline int algo::ch_Max(algo::RspaceStr8& parent) {
16363 (void)parent;
16364 return 8;
16365}
16366
16367// --- algo.RspaceStr8.ch.N
16368inline int algo::ch_N(const algo::RspaceStr8& parent) {
16369 u64 ret;
16370 ret = 8;
16371 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16372 ret--;
16373 }
16374 return int(ret);
16375}
16376
16377// --- algo.RspaceStr8.ch.AssignStrptr
16378// Copy from strptr (operator=)
16379inline void algo::RspaceStr8::operator =(const algo::strptr &str) {
16380 ch_SetStrptr(*this, str);
16381}
16382
16383// --- algo.RspaceStr8.ch.Set
16384// Copy from same type
16385// Copy value from RHS.
16386inline void algo::RspaceStr8::operator =(const algo::RspaceStr8& parent) {
16387 memcpy(ch, parent.ch, 8);
16388}
16389
16390// --- algo.RspaceStr8.ch.Ctor
16391inline algo::RspaceStr8::RspaceStr8(const algo::RspaceStr8 &rhs) {
16392 operator =(rhs);
16393}
16394
16395// --- algo.RspaceStr8.ch.CtorStrptr
16396inline algo::RspaceStr8::RspaceStr8(const algo::strptr &rhs) {
16397 ch_SetStrptr(*this, rhs);
16398}
16399
16400// --- algo.RspaceStr8.ch.Cast
16401inline algo::RspaceStr8::operator algo::strptr () const {
16402 return ch_Getary(*this);
16403}
16404
16405// --- algo.RspaceStr8..Lt
16406inline bool algo::RspaceStr8_Lt(algo::RspaceStr8 lhs, algo::RspaceStr8 rhs) {
16407 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
16408}
16409
16410// --- algo.RspaceStr8..Cmp
16411inline i32 algo::RspaceStr8_Cmp(algo::RspaceStr8 lhs, algo::RspaceStr8 rhs) {
16412 i32 retval = 0;
16413 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16414 return retval;
16415}
16416
16417// --- algo.RspaceStr8..Init
16418// Set all fields to initial values.
16419inline void algo::RspaceStr8_Init(algo::RspaceStr8& parent) {
16420 memset(parent.ch, ' ', 8);
16421}
16422
16423// --- algo.RspaceStr8..Eq
16424inline bool algo::RspaceStr8_Eq(algo::RspaceStr8 lhs, algo::RspaceStr8 rhs) {
16425 bool retval = true;
16426 retval = retval
16427 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0);
16428 return retval;
16429}
16430
16431// --- algo.RspaceStr8..Update
16432// Set value. Return true if new value is different from old value.
16433inline bool algo::RspaceStr8_Update(algo::RspaceStr8 &lhs, algo::RspaceStr8 rhs) {
16434 bool ret = !RspaceStr8_Eq(lhs, rhs); // compare values
16435 if (ret) {
16436 lhs = rhs; // update
16437 }
16438 return ret;
16439}
16440
16441// --- algo.RspaceStr8..EqStrptr
16442inline bool algo::RspaceStr8_EqStrptr(algo::RspaceStr8 lhs, const algo::strptr& rhs) {
16443 return algo::strptr_Eq(ch_Getary(lhs), rhs);
16444}
16445
16446inline bool algo::RspaceStr9::operator ==(const algo::RspaceStr9 &rhs) const {
16447 return algo::RspaceStr9_Eq(const_cast<algo::RspaceStr9&>(*this),const_cast<algo::RspaceStr9&>(rhs));
16448}
16449
16450inline bool algo::RspaceStr9::operator !=(const algo::RspaceStr9 &rhs) const {
16451 return !algo::RspaceStr9_Eq(const_cast<algo::RspaceStr9&>(*this),const_cast<algo::RspaceStr9&>(rhs));
16452}
16453
16454inline bool algo::RspaceStr9::operator ==(const algo::strptr &rhs) const {
16455 return algo::RspaceStr9_EqStrptr(const_cast<algo::RspaceStr9&>(*this),rhs);
16456}
16457inline algo::RspaceStr9::RspaceStr9() {
16458 algo::RspaceStr9_Init(*this);
16459}
16460
16461
16462// --- algo.RspaceStr9.ch.Getary
16463// Access string as array of chars
16464inline algo::aryptr<char> algo::ch_Getary(const algo::RspaceStr9& parent) {
16465 int len = ch_N(parent);
16466 algo::aryptr<char> ret((char*)parent.ch, len);
16467 return ret;
16468}
16469
16470// --- algo.RspaceStr9.ch.HashStrptr
16471inline u32 algo::RspaceStr9_Hash(u32 prev, const algo::strptr &str) {
16472 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16473}
16474
16475// --- algo.RspaceStr9.ch.Init
16476inline void algo::ch_Init(algo::RspaceStr9 &parent) {
16477 memset(parent.ch, ' ', 9);
16478}
16479
16480// --- algo.RspaceStr9.ch.Max
16481// always return constant 9
16482inline int algo::ch_Max(algo::RspaceStr9& parent) {
16483 (void)parent;
16484 return 9;
16485}
16486
16487// --- algo.RspaceStr9.ch.N
16488inline int algo::ch_N(const algo::RspaceStr9& parent) {
16489 u64 ret;
16490 ret = 9;
16491 while (ret>0 && parent.ch[ret-1]==u8(' ')) {
16492 ret--;
16493 }
16494 return int(ret);
16495}
16496
16497// --- algo.RspaceStr9.ch.AssignStrptr
16498// Copy from strptr (operator=)
16499inline void algo::RspaceStr9::operator =(const algo::strptr &str) {
16500 ch_SetStrptr(*this, str);
16501}
16502
16503// --- algo.RspaceStr9.ch.Set
16504// Copy from same type
16505// Copy value from RHS.
16506inline void algo::RspaceStr9::operator =(const algo::RspaceStr9& parent) {
16507 memcpy(ch, parent.ch, 9);
16508}
16509
16510// --- algo.RspaceStr9.ch.Ctor
16511inline algo::RspaceStr9::RspaceStr9(const algo::RspaceStr9 &rhs) {
16512 operator =(rhs);
16513}
16514
16515// --- algo.RspaceStr9.ch.CtorStrptr
16516inline algo::RspaceStr9::RspaceStr9(const algo::strptr &rhs) {
16517 ch_SetStrptr(*this, rhs);
16518}
16519
16520// --- algo.RspaceStr9.ch.Cast
16521inline algo::RspaceStr9::operator algo::strptr () const {
16522 return ch_Getary(*this);
16523}
16524
16525// --- algo.RspaceStr9..Cmp
16526inline i32 algo::RspaceStr9_Cmp(algo::RspaceStr9& lhs, algo::RspaceStr9& rhs) {
16527 i32 retval = 0;
16528 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16529 return retval;
16530}
16531
16532// --- algo.RspaceStr9..Init
16533// Set all fields to initial values.
16534inline void algo::RspaceStr9_Init(algo::RspaceStr9& parent) {
16535 memset(parent.ch, ' ', 9);
16536}
16537
16538// --- algo.RspaceStr9..Eq
16539inline bool algo::RspaceStr9_Eq(algo::RspaceStr9& lhs, algo::RspaceStr9& rhs) {
16540 bool retval = true;
16541 retval = retval
16542 &&*(u64*)(lhs.ch+0) == *(u64*)(rhs.ch+0)
16543 &&*(u8*)(lhs.ch+8) == *(u8*)(rhs.ch+8);
16544 return retval;
16545}
16546
16547// --- algo.RspaceStr9..EqStrptr
16548inline bool algo::RspaceStr9_EqStrptr(const algo::RspaceStr9& lhs, const algo::strptr& rhs) {
16549 return algo::strptr_Eq(ch_Getary(lhs), rhs);
16550}
16551inline algo::SchedTime::SchedTime(u64 in_value)
16552 : value(in_value)
16553{
16554}
16555inline algo::SchedTime::SchedTime() {
16556 algo::SchedTime_Init(*this);
16557}
16558
16559
16560// --- algo.SchedTime.value.Cast
16561inline algo::SchedTime::operator u64 () const {
16562 return u64((*this).value);
16563}
16564
16565// --- algo.SchedTime..Lt
16566inline bool algo::SchedTime_Lt(algo::SchedTime lhs, algo::SchedTime rhs) {
16567 return u64_Lt(lhs.value, rhs.value);
16568}
16569
16570// --- algo.SchedTime..Cmp
16571inline i32 algo::SchedTime_Cmp(algo::SchedTime lhs, algo::SchedTime rhs) {
16572 i32 retval = 0;
16573 retval = u64_Cmp(lhs.value, rhs.value);
16574 return retval;
16575}
16576
16577// --- algo.SchedTime..Init
16578// Set all fields to initial values.
16579inline void algo::SchedTime_Init(algo::SchedTime& parent) {
16580 parent.value = u64(0);
16581}
16582
16583// --- algo.SchedTime..Eq
16584inline bool algo::SchedTime_Eq(algo::SchedTime lhs, algo::SchedTime rhs) {
16585 bool retval = true;
16586 retval = u64_Eq(lhs.value, rhs.value);
16587 return retval;
16588}
16589
16590// --- algo.SchedTime..Update
16591// Set value. Return true if new value is different from old value.
16592inline bool algo::SchedTime_Update(algo::SchedTime &lhs, algo::SchedTime rhs) {
16593 bool ret = !SchedTime_Eq(lhs, rhs); // compare values
16594 if (ret) {
16595 lhs = rhs; // update
16596 }
16597 return ret;
16598}
16599inline algo::SeqType::SeqType(u64 in_value)
16600 : value(in_value)
16601{
16602}
16603inline algo::SeqType::SeqType() {
16604 algo::SeqType_Init(*this);
16605}
16606
16607
16608// --- algo.SeqType.value.Cast
16609inline algo::SeqType::operator u64 () const {
16610 return u64((*this).value);
16611}
16612
16613// --- algo.SeqType..Hash
16614inline u32 algo::SeqType_Hash(u32 prev, algo::SeqType rhs) {
16615 prev = u64_Hash(prev, rhs.value);
16616 return prev;
16617}
16618
16619// --- algo.SeqType..Lt
16620inline bool algo::SeqType_Lt(algo::SeqType lhs, algo::SeqType rhs) {
16621 return u64_Lt(lhs.value, rhs.value);
16622}
16623
16624// --- algo.SeqType..Cmp
16625inline i32 algo::SeqType_Cmp(algo::SeqType lhs, algo::SeqType rhs) {
16626 i32 retval = 0;
16627 retval = u64_Cmp(lhs.value, rhs.value);
16628 return retval;
16629}
16630
16631// --- algo.SeqType..Init
16632// Set all fields to initial values.
16633inline void algo::SeqType_Init(algo::SeqType& parent) {
16634 parent.value = u64(0);
16635}
16636
16637// --- algo.SeqType..Eq
16638inline bool algo::SeqType_Eq(algo::SeqType lhs, algo::SeqType rhs) {
16639 bool retval = true;
16640 retval = u64_Eq(lhs.value, rhs.value);
16641 return retval;
16642}
16643
16644// --- algo.SeqType..Update
16645// Set value. Return true if new value is different from old value.
16646inline bool algo::SeqType_Update(algo::SeqType &lhs, algo::SeqType rhs) {
16647 bool ret = !SeqType_Eq(lhs, rhs); // compare values
16648 if (ret) {
16649 lhs = rhs; // update
16650 }
16651 return ret;
16652}
16653
16654inline bool algo::Sha1sig::operator ==(const algo::Sha1sig &rhs) const {
16655 return algo::Sha1sig_Eq(const_cast<algo::Sha1sig&>(*this),const_cast<algo::Sha1sig&>(rhs));
16656}
16657
16658inline bool algo::Sha1sig::operator !=(const algo::Sha1sig &rhs) const {
16659 return !algo::Sha1sig_Eq(const_cast<algo::Sha1sig&>(*this),const_cast<algo::Sha1sig&>(rhs));
16660}
16661
16662inline bool algo::Sha1sig::operator <(const algo::Sha1sig &rhs) const {
16663 return algo::Sha1sig_Lt(const_cast<algo::Sha1sig&>(*this),const_cast<algo::Sha1sig&>(rhs));
16664}
16665
16666inline bool algo::Sha1sig::operator >(const algo::Sha1sig &rhs) const {
16667 return rhs < *this;
16668}
16669
16670inline bool algo::Sha1sig::operator <=(const algo::Sha1sig &rhs) const {
16671 return !(rhs < *this);
16672}
16673
16674inline bool algo::Sha1sig::operator >=(const algo::Sha1sig &rhs) const {
16675 return !(*this < rhs);
16676}
16677inline algo::Sha1sig::Sha1sig() {
16678 algo::Sha1sig_Init(*this);
16679}
16680
16681
16682// --- algo.Sha1sig.sha1sig.Fill
16683// Set all elements of fixed array to value RHS
16684inline void algo::sha1sig_Fill(algo::Sha1sig& parent, const u8 &rhs) {
16685 for (int i = 0; i < 20; i++) {
16686 parent.sha1sig_elems[i] = rhs;
16687 }
16688}
16689
16690// --- algo.Sha1sig.sha1sig.Find
16691// Look up row by row id. Return NULL if out of range
16692inline u8* algo::sha1sig_Find(algo::Sha1sig& parent, u64 t) {
16693 u64 idx = t;
16694 u64 lim = 20;
16695 return idx < lim ? parent.sha1sig_elems + idx : NULL; // unsigned comparison with limit
16696}
16697
16698// --- algo.Sha1sig.sha1sig.Getary
16699// Access fixed array sha1sig as aryptr.
16700inline algo::aryptr<u8> algo::sha1sig_Getary(algo::Sha1sig& parent) {
16701 return algo::aryptr<u8>(parent.sha1sig_elems, 20);
16702}
16703
16704// --- algo.Sha1sig.sha1sig.Max
16705// Return max number of items in the array
16706inline i32 algo::sha1sig_Max(algo::Sha1sig& parent) {
16707 (void)parent;
16708 return 20;
16709}
16710
16711// --- algo.Sha1sig.sha1sig.N
16712// Return number of items in the array
16713inline i32 algo::sha1sig_N(const algo::Sha1sig& parent) {
16714 (void)parent;//only to avoid -Wunused-parameter
16715 return 20;
16716}
16717
16718// --- algo.Sha1sig.sha1sig.Setary
16719// Set contents of fixed array to RHS; Input length is trimmed as necessary
16720inline void algo::sha1sig_Setary(algo::Sha1sig& parent, const algo::aryptr<u8> &rhs) {
16721 int n = 20 < rhs.n_elems ? 20 : rhs.n_elems;
16722 for (int i = 0; i < n; i++) {
16723 parent.sha1sig_elems[i] = rhs[i];
16724 }
16725}
16726
16727// --- algo.Sha1sig.sha1sig.qFind
16728// 'quick' Access row by row id. No bounds checking in release.
16729inline u8& algo::sha1sig_qFind(algo::Sha1sig& parent, u64 t) {
16730 return parent.sha1sig_elems[u64(t)];
16731}
16732
16733// --- algo.Sha1sig.sha1sig_curs.Reset
16734// cursor points to valid item
16735inline void algo::Sha1sig_sha1sig_curs_Reset(Sha1sig_sha1sig_curs &curs, algo::Sha1sig &parent) {
16736 curs.parent = &parent;
16737 curs.index = 0;
16738}
16739
16740// --- algo.Sha1sig.sha1sig_curs.ValidQ
16741// cursor points to valid item
16742inline bool algo::Sha1sig_sha1sig_curs_ValidQ(Sha1sig_sha1sig_curs &curs) {
16743 return u64(curs.index) < u64(20);
16744}
16745
16746// --- algo.Sha1sig.sha1sig_curs.Next
16747// proceed to next item
16748inline void algo::Sha1sig_sha1sig_curs_Next(Sha1sig_sha1sig_curs &curs) {
16749 curs.index++;
16750}
16751
16752// --- algo.Sha1sig.sha1sig_curs.Access
16753// item access
16754inline u8& algo::Sha1sig_sha1sig_curs_Access(Sha1sig_sha1sig_curs &curs) {
16755 return sha1sig_qFind((*curs.parent), u64(curs.index));
16756}
16757
16758// --- algo.Sha1sig..Lt
16759inline bool algo::Sha1sig_Lt(algo::Sha1sig& lhs, algo::Sha1sig& rhs) {
16760 return sha1sig_Cmp(lhs,rhs) < 0;
16761}
16762
16763// --- algo.Sha1sig..Cmp
16764inline i32 algo::Sha1sig_Cmp(algo::Sha1sig& lhs, algo::Sha1sig& rhs) {
16765 i32 retval = 0;
16766 retval = sha1sig_Cmp(lhs,rhs);
16767 return retval;
16768}
16769
16770// --- algo.Sha1sig..Init
16771// Set all fields to initial values.
16772inline void algo::Sha1sig_Init(algo::Sha1sig& parent) {
16773 for (int i = 0; i < 20; i++) {
16774 parent.sha1sig_elems[i] = 0;
16775 }
16776}
16777
16778// --- algo.Sha1sig..Eq
16779inline bool algo::Sha1sig_Eq(algo::Sha1sig& lhs, algo::Sha1sig& rhs) {
16780 bool retval = true;
16781 retval = sha1sig_Eq(lhs,rhs);
16782 return retval;
16783}
16784
16785// --- algo.Sha1sig..Update
16786// Set value. Return true if new value is different from old value.
16787inline bool algo::Sha1sig_Update(algo::Sha1sig &lhs, algo::Sha1sig& rhs) {
16788 bool ret = !Sha1sig_Eq(lhs, rhs); // compare values
16789 if (ret) {
16790 lhs = rhs; // update
16791 }
16792 return ret;
16793}
16794
16795inline bool algo::Smallstr1::operator ==(const algo::Smallstr1 &rhs) const {
16796 return algo::Smallstr1_Eq(const_cast<algo::Smallstr1&>(*this),const_cast<algo::Smallstr1&>(rhs));
16797}
16798
16799inline bool algo::Smallstr1::operator !=(const algo::Smallstr1 &rhs) const {
16800 return !algo::Smallstr1_Eq(const_cast<algo::Smallstr1&>(*this),const_cast<algo::Smallstr1&>(rhs));
16801}
16802
16803inline bool algo::Smallstr1::operator ==(const algo::strptr &rhs) const {
16804 return algo::Smallstr1_EqStrptr(const_cast<algo::Smallstr1&>(*this),rhs);
16805}
16806inline algo::Smallstr1::Smallstr1() {
16807 algo::Smallstr1_Init(*this);
16808}
16809
16810
16811// --- algo.Smallstr1.ch.Add
16812// Append character to string.
16813// If there is no space for an extra character, do nothing.
16814inline void algo::ch_Add(algo::Smallstr1& parent, char c) {
16815 if (parent.n_ch < 1) {
16816 parent.ch[parent.n_ch++] = c;
16817 }
16818}
16819
16820// --- algo.Smallstr1.ch.AddStrptr
16821// Append string to this string.
16822// If there is no space for an extra character, trim.
16823// If there is no space left, dump core in debug mode.
16824inline void algo::ch_AddStrptr(algo::Smallstr1& parent, algo::strptr str) {
16825 int n_new = str.n_elems;
16826 if (parent.n_ch + n_new > 1) {
16827 n_new = 1 - parent.n_ch;
16828 }
16829 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
16830 parent.n_ch = u8(parent.n_ch + n_new);
16831}
16832
16833// --- algo.Smallstr1.ch.Getary
16834// Access string as array of chars
16835inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr1& parent) {
16836 int len = ch_N(parent);
16837 algo::aryptr<char> ret((char*)parent.ch, len);
16838 return ret;
16839}
16840
16841// --- algo.Smallstr1.ch.HashStrptr
16842inline u32 algo::Smallstr1_Hash(u32 prev, const algo::strptr &str) {
16843 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16844}
16845
16846// --- algo.Smallstr1.ch.Init
16847inline void algo::ch_Init(algo::Smallstr1 &parent) {
16848 parent.n_ch = 0;
16849}
16850
16851// --- algo.Smallstr1.ch.Max
16852// always return constant 1
16853inline int algo::ch_Max(algo::Smallstr1& parent) {
16854 (void)parent;
16855 return 1;
16856}
16857
16858// --- algo.Smallstr1.ch.N
16859inline int algo::ch_N(const algo::Smallstr1& parent) {
16860 u64 ret;
16861 ret = parent.n_ch;
16862 return int(ret);
16863}
16864
16865// --- algo.Smallstr1.ch.AssignStrptr
16866// Copy from strptr (operator=)
16867inline void algo::Smallstr1::operator =(const algo::strptr &str) {
16868 ch_SetStrptr(*this, str);
16869}
16870
16871// --- algo.Smallstr1.ch.Set
16872// Copy from same type
16873// Copy value from RHS.
16874inline void algo::Smallstr1::operator =(const algo::Smallstr1& parent) {
16875 memcpy(ch, parent.ch, parent.n_ch);
16876 n_ch = parent.n_ch;
16877}
16878
16879// --- algo.Smallstr1.ch.Ctor
16880inline algo::Smallstr1::Smallstr1(const algo::Smallstr1 &rhs) {
16881 operator =(rhs);
16882}
16883
16884// --- algo.Smallstr1.ch.CtorStrptr
16885inline algo::Smallstr1::Smallstr1(const algo::strptr &rhs) {
16886 ch_SetStrptr(*this, rhs);
16887}
16888
16889// --- algo.Smallstr1.ch.Cast
16890inline algo::Smallstr1::operator algo::strptr () const {
16891 return ch_Getary(*this);
16892}
16893
16894// --- algo.Smallstr1..Cmp
16895inline i32 algo::Smallstr1_Cmp(algo::Smallstr1& lhs, algo::Smallstr1& rhs) {
16896 i32 retval = 0;
16897 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
16898 return retval;
16899}
16900
16901// --- algo.Smallstr1..Init
16902// Set all fields to initial values.
16903inline void algo::Smallstr1_Init(algo::Smallstr1& parent) {
16904 parent.n_ch = 0;
16905}
16906
16907// --- algo.Smallstr1..Eq
16908inline bool algo::Smallstr1_Eq(algo::Smallstr1& lhs, algo::Smallstr1& rhs) {
16909 bool retval = true;
16910 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
16911 return retval;
16912}
16913
16914// --- algo.Smallstr1..EqStrptr
16915inline bool algo::Smallstr1_EqStrptr(const algo::Smallstr1& lhs, const algo::strptr& rhs) {
16916 return algo::strptr_Eq(ch_Getary(lhs), rhs);
16917}
16918
16919inline bool algo::Smallstr10::operator ==(const algo::Smallstr10 &rhs) const {
16920 return algo::Smallstr10_Eq(const_cast<algo::Smallstr10&>(*this),const_cast<algo::Smallstr10&>(rhs));
16921}
16922
16923inline bool algo::Smallstr10::operator !=(const algo::Smallstr10 &rhs) const {
16924 return !algo::Smallstr10_Eq(const_cast<algo::Smallstr10&>(*this),const_cast<algo::Smallstr10&>(rhs));
16925}
16926
16927inline bool algo::Smallstr10::operator ==(const algo::strptr &rhs) const {
16928 return algo::Smallstr10_EqStrptr(const_cast<algo::Smallstr10&>(*this),rhs);
16929}
16930inline algo::Smallstr10::Smallstr10() {
16931 algo::Smallstr10_Init(*this);
16932}
16933
16934
16935// --- algo.Smallstr10.ch.Add
16936// Append character to string.
16937// If there is no space for an extra character, do nothing.
16938inline void algo::ch_Add(algo::Smallstr10& parent, char c) {
16939 if (parent.n_ch < 10) {
16940 parent.ch[parent.n_ch++] = c;
16941 }
16942}
16943
16944// --- algo.Smallstr10.ch.AddStrptr
16945// Append string to this string.
16946// If there is no space for an extra character, trim.
16947// If there is no space left, dump core in debug mode.
16948inline void algo::ch_AddStrptr(algo::Smallstr10& parent, algo::strptr str) {
16949 int n_new = str.n_elems;
16950 if (parent.n_ch + n_new > 10) {
16951 n_new = 10 - parent.n_ch;
16952 }
16953 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
16954 parent.n_ch = u8(parent.n_ch + n_new);
16955}
16956
16957// --- algo.Smallstr10.ch.Getary
16958// Access string as array of chars
16959inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr10& parent) {
16960 int len = ch_N(parent);
16961 algo::aryptr<char> ret((char*)parent.ch, len);
16962 return ret;
16963}
16964
16965// --- algo.Smallstr10.ch.HashStrptr
16966inline u32 algo::Smallstr10_Hash(u32 prev, const algo::strptr &str) {
16967 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
16968}
16969
16970// --- algo.Smallstr10.ch.Init
16971inline void algo::ch_Init(algo::Smallstr10 &parent) {
16972 parent.n_ch = 0;
16973}
16974
16975// --- algo.Smallstr10.ch.Max
16976// always return constant 10
16977inline int algo::ch_Max(algo::Smallstr10& parent) {
16978 (void)parent;
16979 return 10;
16980}
16981
16982// --- algo.Smallstr10.ch.N
16983inline int algo::ch_N(const algo::Smallstr10& parent) {
16984 u64 ret;
16985 ret = parent.n_ch;
16986 return int(ret);
16987}
16988
16989// --- algo.Smallstr10.ch.AssignStrptr
16990// Copy from strptr (operator=)
16991inline void algo::Smallstr10::operator =(const algo::strptr &str) {
16992 ch_SetStrptr(*this, str);
16993}
16994
16995// --- algo.Smallstr10.ch.Set
16996// Copy from same type
16997// Copy value from RHS.
16998inline void algo::Smallstr10::operator =(const algo::Smallstr10& parent) {
16999 memcpy(ch, parent.ch, parent.n_ch);
17000 n_ch = parent.n_ch;
17001}
17002
17003// --- algo.Smallstr10.ch.Ctor
17004inline algo::Smallstr10::Smallstr10(const algo::Smallstr10 &rhs) {
17005 operator =(rhs);
17006}
17007
17008// --- algo.Smallstr10.ch.CtorStrptr
17009inline algo::Smallstr10::Smallstr10(const algo::strptr &rhs) {
17010 ch_SetStrptr(*this, rhs);
17011}
17012
17013// --- algo.Smallstr10.ch.Cast
17014inline algo::Smallstr10::operator algo::strptr () const {
17015 return ch_Getary(*this);
17016}
17017
17018// --- algo.Smallstr10..Cmp
17019inline i32 algo::Smallstr10_Cmp(algo::Smallstr10& lhs, algo::Smallstr10& rhs) {
17020 i32 retval = 0;
17021 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17022 return retval;
17023}
17024
17025// --- algo.Smallstr10..Init
17026// Set all fields to initial values.
17027inline void algo::Smallstr10_Init(algo::Smallstr10& parent) {
17028 parent.n_ch = 0;
17029}
17030
17031// --- algo.Smallstr10..Eq
17032inline bool algo::Smallstr10_Eq(algo::Smallstr10& lhs, algo::Smallstr10& rhs) {
17033 bool retval = true;
17034 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17035 return retval;
17036}
17037
17038// --- algo.Smallstr10..EqStrptr
17039inline bool algo::Smallstr10_EqStrptr(const algo::Smallstr10& lhs, const algo::strptr& rhs) {
17040 return algo::strptr_Eq(ch_Getary(lhs), rhs);
17041}
17042
17043inline bool algo::Smallstr16::operator ==(const algo::Smallstr16 &rhs) const {
17044 return algo::Smallstr16_Eq(const_cast<algo::Smallstr16&>(*this),const_cast<algo::Smallstr16&>(rhs));
17045}
17046
17047inline bool algo::Smallstr16::operator !=(const algo::Smallstr16 &rhs) const {
17048 return !algo::Smallstr16_Eq(const_cast<algo::Smallstr16&>(*this),const_cast<algo::Smallstr16&>(rhs));
17049}
17050
17051inline bool algo::Smallstr16::operator ==(const algo::strptr &rhs) const {
17052 return algo::Smallstr16_EqStrptr(const_cast<algo::Smallstr16&>(*this),rhs);
17053}
17054inline algo::Smallstr16::Smallstr16() {
17055 algo::Smallstr16_Init(*this);
17056}
17057
17058
17059// --- algo.Smallstr16.ch.Add
17060// Append character to string.
17061// If there is no space for an extra character, do nothing.
17062inline void algo::ch_Add(algo::Smallstr16& parent, char c) {
17063 if (parent.n_ch < 16) {
17064 parent.ch[parent.n_ch++] = c;
17065 }
17066}
17067
17068// --- algo.Smallstr16.ch.AddStrptr
17069// Append string to this string.
17070// If there is no space for an extra character, trim.
17071// If there is no space left, dump core in debug mode.
17072inline void algo::ch_AddStrptr(algo::Smallstr16& parent, algo::strptr str) {
17073 int n_new = str.n_elems;
17074 if (parent.n_ch + n_new > 16) {
17075 n_new = 16 - parent.n_ch;
17076 }
17077 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17078 parent.n_ch = u8(parent.n_ch + n_new);
17079}
17080
17081// --- algo.Smallstr16.ch.Getary
17082// Access string as array of chars
17083inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr16& parent) {
17084 int len = ch_N(parent);
17085 algo::aryptr<char> ret((char*)parent.ch, len);
17086 return ret;
17087}
17088
17089// --- algo.Smallstr16.ch.HashStrptr
17090inline u32 algo::Smallstr16_Hash(u32 prev, const algo::strptr &str) {
17091 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17092}
17093
17094// --- algo.Smallstr16.ch.Init
17095inline void algo::ch_Init(algo::Smallstr16 &parent) {
17096 parent.n_ch = 0;
17097}
17098
17099// --- algo.Smallstr16.ch.Max
17100// always return constant 16
17101inline int algo::ch_Max(algo::Smallstr16& parent) {
17102 (void)parent;
17103 return 16;
17104}
17105
17106// --- algo.Smallstr16.ch.N
17107inline int algo::ch_N(const algo::Smallstr16& parent) {
17108 u64 ret;
17109 ret = parent.n_ch;
17110 return int(ret);
17111}
17112
17113// --- algo.Smallstr16.ch.AssignStrptr
17114// Copy from strptr (operator=)
17115inline void algo::Smallstr16::operator =(const algo::strptr &str) {
17116 ch_SetStrptr(*this, str);
17117}
17118
17119// --- algo.Smallstr16.ch.Set
17120// Copy from same type
17121// Copy value from RHS.
17122inline void algo::Smallstr16::operator =(const algo::Smallstr16& parent) {
17123 memcpy(ch, parent.ch, parent.n_ch);
17124 n_ch = parent.n_ch;
17125}
17126
17127// --- algo.Smallstr16.ch.Ctor
17128inline algo::Smallstr16::Smallstr16(const algo::Smallstr16 &rhs) {
17129 operator =(rhs);
17130}
17131
17132// --- algo.Smallstr16.ch.CtorStrptr
17133inline algo::Smallstr16::Smallstr16(const algo::strptr &rhs) {
17134 ch_SetStrptr(*this, rhs);
17135}
17136
17137// --- algo.Smallstr16.ch.Cast
17138inline algo::Smallstr16::operator algo::strptr () const {
17139 return ch_Getary(*this);
17140}
17141
17142// --- algo.Smallstr16..Cmp
17143inline i32 algo::Smallstr16_Cmp(algo::Smallstr16& lhs, algo::Smallstr16& rhs) {
17144 i32 retval = 0;
17145 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17146 return retval;
17147}
17148
17149// --- algo.Smallstr16..Init
17150// Set all fields to initial values.
17151inline void algo::Smallstr16_Init(algo::Smallstr16& parent) {
17152 parent.n_ch = 0;
17153}
17154
17155// --- algo.Smallstr16..Eq
17156inline bool algo::Smallstr16_Eq(algo::Smallstr16& lhs, algo::Smallstr16& rhs) {
17157 bool retval = true;
17158 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17159 return retval;
17160}
17161
17162// --- algo.Smallstr16..EqStrptr
17163inline bool algo::Smallstr16_EqStrptr(const algo::Smallstr16& lhs, const algo::strptr& rhs) {
17164 return algo::strptr_Eq(ch_Getary(lhs), rhs);
17165}
17166
17167inline bool algo::Smallstr2::operator ==(const algo::Smallstr2 &rhs) const {
17168 return algo::Smallstr2_Eq(const_cast<algo::Smallstr2&>(*this),const_cast<algo::Smallstr2&>(rhs));
17169}
17170
17171inline bool algo::Smallstr2::operator !=(const algo::Smallstr2 &rhs) const {
17172 return !algo::Smallstr2_Eq(const_cast<algo::Smallstr2&>(*this),const_cast<algo::Smallstr2&>(rhs));
17173}
17174
17175inline bool algo::Smallstr2::operator ==(const algo::strptr &rhs) const {
17176 return algo::Smallstr2_EqStrptr(const_cast<algo::Smallstr2&>(*this),rhs);
17177}
17178inline algo::Smallstr2::Smallstr2() {
17179 algo::Smallstr2_Init(*this);
17180}
17181
17182
17183// --- algo.Smallstr2.ch.Add
17184// Append character to string.
17185// If there is no space for an extra character, do nothing.
17186inline void algo::ch_Add(algo::Smallstr2& parent, char c) {
17187 if (parent.n_ch < 2) {
17188 parent.ch[parent.n_ch++] = c;
17189 }
17190}
17191
17192// --- algo.Smallstr2.ch.AddStrptr
17193// Append string to this string.
17194// If there is no space for an extra character, trim.
17195// If there is no space left, dump core in debug mode.
17196inline void algo::ch_AddStrptr(algo::Smallstr2& parent, algo::strptr str) {
17197 int n_new = str.n_elems;
17198 if (parent.n_ch + n_new > 2) {
17199 n_new = 2 - parent.n_ch;
17200 }
17201 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17202 parent.n_ch = u8(parent.n_ch + n_new);
17203}
17204
17205// --- algo.Smallstr2.ch.Getary
17206// Access string as array of chars
17207inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr2& parent) {
17208 int len = ch_N(parent);
17209 algo::aryptr<char> ret((char*)parent.ch, len);
17210 return ret;
17211}
17212
17213// --- algo.Smallstr2.ch.HashStrptr
17214inline u32 algo::Smallstr2_Hash(u32 prev, const algo::strptr &str) {
17215 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17216}
17217
17218// --- algo.Smallstr2.ch.Init
17219inline void algo::ch_Init(algo::Smallstr2 &parent) {
17220 parent.n_ch = 0;
17221}
17222
17223// --- algo.Smallstr2.ch.Max
17224// always return constant 2
17225inline int algo::ch_Max(algo::Smallstr2& parent) {
17226 (void)parent;
17227 return 2;
17228}
17229
17230// --- algo.Smallstr2.ch.N
17231inline int algo::ch_N(const algo::Smallstr2& parent) {
17232 u64 ret;
17233 ret = parent.n_ch;
17234 return int(ret);
17235}
17236
17237// --- algo.Smallstr2.ch.AssignStrptr
17238// Copy from strptr (operator=)
17239inline void algo::Smallstr2::operator =(const algo::strptr &str) {
17240 ch_SetStrptr(*this, str);
17241}
17242
17243// --- algo.Smallstr2.ch.Set
17244// Copy from same type
17245// Copy value from RHS.
17246inline void algo::Smallstr2::operator =(const algo::Smallstr2& parent) {
17247 memcpy(ch, parent.ch, parent.n_ch);
17248 n_ch = parent.n_ch;
17249}
17250
17251// --- algo.Smallstr2.ch.Ctor
17252inline algo::Smallstr2::Smallstr2(const algo::Smallstr2 &rhs) {
17253 operator =(rhs);
17254}
17255
17256// --- algo.Smallstr2.ch.CtorStrptr
17257inline algo::Smallstr2::Smallstr2(const algo::strptr &rhs) {
17258 ch_SetStrptr(*this, rhs);
17259}
17260
17261// --- algo.Smallstr2.ch.Cast
17262inline algo::Smallstr2::operator algo::strptr () const {
17263 return ch_Getary(*this);
17264}
17265
17266// --- algo.Smallstr2..Cmp
17267inline i32 algo::Smallstr2_Cmp(algo::Smallstr2& lhs, algo::Smallstr2& rhs) {
17268 i32 retval = 0;
17269 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17270 return retval;
17271}
17272
17273// --- algo.Smallstr2..Init
17274// Set all fields to initial values.
17275inline void algo::Smallstr2_Init(algo::Smallstr2& parent) {
17276 parent.n_ch = 0;
17277}
17278
17279// --- algo.Smallstr2..Eq
17280inline bool algo::Smallstr2_Eq(algo::Smallstr2& lhs, algo::Smallstr2& rhs) {
17281 bool retval = true;
17282 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17283 return retval;
17284}
17285
17286// --- algo.Smallstr2..EqStrptr
17287inline bool algo::Smallstr2_EqStrptr(const algo::Smallstr2& lhs, const algo::strptr& rhs) {
17288 return algo::strptr_Eq(ch_Getary(lhs), rhs);
17289}
17290
17291inline bool algo::Smallstr20::operator ==(const algo::Smallstr20 &rhs) const {
17292 return algo::Smallstr20_Eq(const_cast<algo::Smallstr20&>(*this),const_cast<algo::Smallstr20&>(rhs));
17293}
17294
17295inline bool algo::Smallstr20::operator !=(const algo::Smallstr20 &rhs) const {
17296 return !algo::Smallstr20_Eq(const_cast<algo::Smallstr20&>(*this),const_cast<algo::Smallstr20&>(rhs));
17297}
17298
17299inline bool algo::Smallstr20::operator ==(const algo::strptr &rhs) const {
17300 return algo::Smallstr20_EqStrptr(const_cast<algo::Smallstr20&>(*this),rhs);
17301}
17302
17303inline bool algo::Smallstr20::operator <(const algo::Smallstr20 &rhs) const {
17304 return algo::Smallstr20_Lt(const_cast<algo::Smallstr20&>(*this),const_cast<algo::Smallstr20&>(rhs));
17305}
17306
17307inline bool algo::Smallstr20::operator >(const algo::Smallstr20 &rhs) const {
17308 return rhs < *this;
17309}
17310
17311inline bool algo::Smallstr20::operator <=(const algo::Smallstr20 &rhs) const {
17312 return !(rhs < *this);
17313}
17314
17315inline bool algo::Smallstr20::operator >=(const algo::Smallstr20 &rhs) const {
17316 return !(*this < rhs);
17317}
17318inline algo::Smallstr20::Smallstr20() {
17319 algo::Smallstr20_Init(*this);
17320}
17321
17322
17323// --- algo.Smallstr20.ch.Add
17324// Append character to string.
17325// If there is no space for an extra character, do nothing.
17326inline void algo::ch_Add(algo::Smallstr20& parent, char c) {
17327 if (parent.n_ch < 20) {
17328 parent.ch[parent.n_ch++] = c;
17329 }
17330}
17331
17332// --- algo.Smallstr20.ch.AddStrptr
17333// Append string to this string.
17334// If there is no space for an extra character, trim.
17335// If there is no space left, dump core in debug mode.
17336inline void algo::ch_AddStrptr(algo::Smallstr20& parent, algo::strptr str) {
17337 int n_new = str.n_elems;
17338 if (parent.n_ch + n_new > 20) {
17339 n_new = 20 - parent.n_ch;
17340 }
17341 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17342 parent.n_ch = u8(parent.n_ch + n_new);
17343}
17344
17345// --- algo.Smallstr20.ch.Getary
17346// Access string as array of chars
17347inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr20& parent) {
17348 int len = ch_N(parent);
17349 algo::aryptr<char> ret((char*)parent.ch, len);
17350 return ret;
17351}
17352
17353// --- algo.Smallstr20.ch.HashStrptr
17354inline u32 algo::Smallstr20_Hash(u32 prev, const algo::strptr &str) {
17355 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17356}
17357
17358// --- algo.Smallstr20.ch.Init
17359inline void algo::ch_Init(algo::Smallstr20 &parent) {
17360 parent.n_ch = 0;
17361}
17362
17363// --- algo.Smallstr20.ch.Max
17364// always return constant 20
17365inline int algo::ch_Max(algo::Smallstr20& parent) {
17366 (void)parent;
17367 return 20;
17368}
17369
17370// --- algo.Smallstr20.ch.N
17371inline int algo::ch_N(const algo::Smallstr20& parent) {
17372 u64 ret;
17373 ret = parent.n_ch;
17374 return int(ret);
17375}
17376
17377// --- algo.Smallstr20.ch.AssignStrptr
17378// Copy from strptr (operator=)
17379inline void algo::Smallstr20::operator =(const algo::strptr &str) {
17380 ch_SetStrptr(*this, str);
17381}
17382
17383// --- algo.Smallstr20.ch.Set
17384// Copy from same type
17385// Copy value from RHS.
17386inline void algo::Smallstr20::operator =(const algo::Smallstr20& parent) {
17387 memcpy(ch, parent.ch, parent.n_ch);
17388 n_ch = parent.n_ch;
17389}
17390
17391// --- algo.Smallstr20.ch.Ctor
17392inline algo::Smallstr20::Smallstr20(const algo::Smallstr20 &rhs) {
17393 operator =(rhs);
17394}
17395
17396// --- algo.Smallstr20.ch.CtorStrptr
17397inline algo::Smallstr20::Smallstr20(const algo::strptr &rhs) {
17398 ch_SetStrptr(*this, rhs);
17399}
17400
17401// --- algo.Smallstr20.ch.Cast
17402inline algo::Smallstr20::operator algo::strptr () const {
17403 return ch_Getary(*this);
17404}
17405
17406// --- algo.Smallstr20..Lt
17407inline bool algo::Smallstr20_Lt(algo::Smallstr20& lhs, algo::Smallstr20& rhs) {
17408 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
17409}
17410
17411// --- algo.Smallstr20..Cmp
17412inline i32 algo::Smallstr20_Cmp(algo::Smallstr20& lhs, algo::Smallstr20& rhs) {
17413 i32 retval = 0;
17414 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17415 return retval;
17416}
17417
17418// --- algo.Smallstr20..Init
17419// Set all fields to initial values.
17420inline void algo::Smallstr20_Init(algo::Smallstr20& parent) {
17421 parent.n_ch = 0;
17422}
17423
17424// --- algo.Smallstr20..Eq
17425inline bool algo::Smallstr20_Eq(algo::Smallstr20& lhs, algo::Smallstr20& rhs) {
17426 bool retval = true;
17427 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17428 return retval;
17429}
17430
17431// --- algo.Smallstr20..Update
17432// Set value. Return true if new value is different from old value.
17433inline bool algo::Smallstr20_Update(algo::Smallstr20 &lhs, algo::Smallstr20& rhs) {
17434 bool ret = !Smallstr20_Eq(lhs, rhs); // compare values
17435 if (ret) {
17436 lhs = rhs; // update
17437 }
17438 return ret;
17439}
17440
17441// --- algo.Smallstr20..EqStrptr
17442inline bool algo::Smallstr20_EqStrptr(const algo::Smallstr20& lhs, const algo::strptr& rhs) {
17443 return algo::strptr_Eq(ch_Getary(lhs), rhs);
17444}
17445
17446inline bool algo::Smallstr200::operator ==(const algo::Smallstr200 &rhs) const {
17447 return algo::Smallstr200_Eq(const_cast<algo::Smallstr200&>(*this),const_cast<algo::Smallstr200&>(rhs));
17448}
17449
17450inline bool algo::Smallstr200::operator !=(const algo::Smallstr200 &rhs) const {
17451 return !algo::Smallstr200_Eq(const_cast<algo::Smallstr200&>(*this),const_cast<algo::Smallstr200&>(rhs));
17452}
17453
17454inline bool algo::Smallstr200::operator ==(const algo::strptr &rhs) const {
17455 return algo::Smallstr200_EqStrptr(const_cast<algo::Smallstr200&>(*this),rhs);
17456}
17457inline algo::Smallstr200::Smallstr200() {
17458 algo::Smallstr200_Init(*this);
17459}
17460
17461
17462// --- algo.Smallstr200.ch.Add
17463// Append character to string.
17464// If there is no space for an extra character, do nothing.
17465inline void algo::ch_Add(algo::Smallstr200& parent, char c) {
17466 if (parent.n_ch < 200) {
17467 parent.ch[parent.n_ch++] = c;
17468 }
17469}
17470
17471// --- algo.Smallstr200.ch.AddStrptr
17472// Append string to this string.
17473// If there is no space for an extra character, trim.
17474// If there is no space left, dump core in debug mode.
17475inline void algo::ch_AddStrptr(algo::Smallstr200& parent, algo::strptr str) {
17476 int n_new = str.n_elems;
17477 if (parent.n_ch + n_new > 200) {
17478 n_new = 200 - parent.n_ch;
17479 }
17480 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17481 parent.n_ch = u8(parent.n_ch + n_new);
17482}
17483
17484// --- algo.Smallstr200.ch.Getary
17485// Access string as array of chars
17486inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr200& parent) {
17487 int len = ch_N(parent);
17488 algo::aryptr<char> ret((char*)parent.ch, len);
17489 return ret;
17490}
17491
17492// --- algo.Smallstr200.ch.HashStrptr
17493inline u32 algo::Smallstr200_Hash(u32 prev, const algo::strptr &str) {
17494 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17495}
17496
17497// --- algo.Smallstr200.ch.Init
17498inline void algo::ch_Init(algo::Smallstr200 &parent) {
17499 parent.n_ch = 0;
17500}
17501
17502// --- algo.Smallstr200.ch.Max
17503// always return constant 200
17504inline int algo::ch_Max(algo::Smallstr200& parent) {
17505 (void)parent;
17506 return 200;
17507}
17508
17509// --- algo.Smallstr200.ch.N
17510inline int algo::ch_N(const algo::Smallstr200& parent) {
17511 u64 ret;
17512 ret = parent.n_ch;
17513 return int(ret);
17514}
17515
17516// --- algo.Smallstr200.ch.AssignStrptr
17517// Copy from strptr (operator=)
17518inline void algo::Smallstr200::operator =(const algo::strptr &str) {
17519 ch_SetStrptr(*this, str);
17520}
17521
17522// --- algo.Smallstr200.ch.Set
17523// Copy from same type
17524// Copy value from RHS.
17525inline void algo::Smallstr200::operator =(const algo::Smallstr200& parent) {
17526 memcpy(ch, parent.ch, parent.n_ch);
17527 n_ch = parent.n_ch;
17528}
17529
17530// --- algo.Smallstr200.ch.Ctor
17531inline algo::Smallstr200::Smallstr200(const algo::Smallstr200 &rhs) {
17532 operator =(rhs);
17533}
17534
17535// --- algo.Smallstr200.ch.CtorStrptr
17536inline algo::Smallstr200::Smallstr200(const algo::strptr &rhs) {
17537 ch_SetStrptr(*this, rhs);
17538}
17539
17540// --- algo.Smallstr200.ch.Cast
17541inline algo::Smallstr200::operator algo::strptr () const {
17542 return ch_Getary(*this);
17543}
17544
17545// --- algo.Smallstr200..Cmp
17546inline i32 algo::Smallstr200_Cmp(algo::Smallstr200& lhs, algo::Smallstr200& rhs) {
17547 i32 retval = 0;
17548 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17549 return retval;
17550}
17551
17552// --- algo.Smallstr200..Init
17553// Set all fields to initial values.
17554inline void algo::Smallstr200_Init(algo::Smallstr200& parent) {
17555 parent.n_ch = 0;
17556}
17557
17558// --- algo.Smallstr200..Eq
17559inline bool algo::Smallstr200_Eq(algo::Smallstr200& lhs, algo::Smallstr200& rhs) {
17560 bool retval = true;
17561 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17562 return retval;
17563}
17564
17565// --- algo.Smallstr200..EqStrptr
17566inline bool algo::Smallstr200_EqStrptr(const algo::Smallstr200& lhs, const algo::strptr& rhs) {
17567 return algo::strptr_Eq(ch_Getary(lhs), rhs);
17568}
17569
17570inline bool algo::Smallstr25::operator ==(const algo::Smallstr25 &rhs) const {
17571 return algo::Smallstr25_Eq(const_cast<algo::Smallstr25&>(*this),const_cast<algo::Smallstr25&>(rhs));
17572}
17573
17574inline bool algo::Smallstr25::operator !=(const algo::Smallstr25 &rhs) const {
17575 return !algo::Smallstr25_Eq(const_cast<algo::Smallstr25&>(*this),const_cast<algo::Smallstr25&>(rhs));
17576}
17577
17578inline bool algo::Smallstr25::operator ==(const algo::strptr &rhs) const {
17579 return algo::Smallstr25_EqStrptr(const_cast<algo::Smallstr25&>(*this),rhs);
17580}
17581inline algo::Smallstr25::Smallstr25() {
17582 algo::Smallstr25_Init(*this);
17583}
17584
17585
17586// --- algo.Smallstr25.ch.Add
17587// Append character to string.
17588// If there is no space for an extra character, do nothing.
17589inline void algo::ch_Add(algo::Smallstr25& parent, char c) {
17590 if (parent.n_ch < 25) {
17591 parent.ch[parent.n_ch++] = c;
17592 }
17593}
17594
17595// --- algo.Smallstr25.ch.AddStrptr
17596// Append string to this string.
17597// If there is no space for an extra character, trim.
17598// If there is no space left, dump core in debug mode.
17599inline void algo::ch_AddStrptr(algo::Smallstr25& parent, algo::strptr str) {
17600 int n_new = str.n_elems;
17601 if (parent.n_ch + n_new > 25) {
17602 n_new = 25 - parent.n_ch;
17603 }
17604 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17605 parent.n_ch = u8(parent.n_ch + n_new);
17606}
17607
17608// --- algo.Smallstr25.ch.Getary
17609// Access string as array of chars
17610inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr25& parent) {
17611 int len = ch_N(parent);
17612 algo::aryptr<char> ret((char*)parent.ch, len);
17613 return ret;
17614}
17615
17616// --- algo.Smallstr25.ch.HashStrptr
17617inline u32 algo::Smallstr25_Hash(u32 prev, const algo::strptr &str) {
17618 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17619}
17620
17621// --- algo.Smallstr25.ch.Init
17622inline void algo::ch_Init(algo::Smallstr25 &parent) {
17623 parent.n_ch = 0;
17624}
17625
17626// --- algo.Smallstr25.ch.Max
17627// always return constant 25
17628inline int algo::ch_Max(algo::Smallstr25& parent) {
17629 (void)parent;
17630 return 25;
17631}
17632
17633// --- algo.Smallstr25.ch.N
17634inline int algo::ch_N(const algo::Smallstr25& parent) {
17635 u64 ret;
17636 ret = parent.n_ch;
17637 return int(ret);
17638}
17639
17640// --- algo.Smallstr25.ch.AssignStrptr
17641// Copy from strptr (operator=)
17642inline void algo::Smallstr25::operator =(const algo::strptr &str) {
17643 ch_SetStrptr(*this, str);
17644}
17645
17646// --- algo.Smallstr25.ch.Set
17647// Copy from same type
17648// Copy value from RHS.
17649inline void algo::Smallstr25::operator =(const algo::Smallstr25& parent) {
17650 memcpy(ch, parent.ch, parent.n_ch);
17651 n_ch = parent.n_ch;
17652}
17653
17654// --- algo.Smallstr25.ch.Ctor
17655inline algo::Smallstr25::Smallstr25(const algo::Smallstr25 &rhs) {
17656 operator =(rhs);
17657}
17658
17659// --- algo.Smallstr25.ch.CtorStrptr
17660inline algo::Smallstr25::Smallstr25(const algo::strptr &rhs) {
17661 ch_SetStrptr(*this, rhs);
17662}
17663
17664// --- algo.Smallstr25.ch.Cast
17665inline algo::Smallstr25::operator algo::strptr () const {
17666 return ch_Getary(*this);
17667}
17668
17669// --- algo.Smallstr25..Cmp
17670inline i32 algo::Smallstr25_Cmp(algo::Smallstr25& lhs, algo::Smallstr25& rhs) {
17671 i32 retval = 0;
17672 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17673 return retval;
17674}
17675
17676// --- algo.Smallstr25..Init
17677// Set all fields to initial values.
17678inline void algo::Smallstr25_Init(algo::Smallstr25& parent) {
17679 parent.n_ch = 0;
17680}
17681
17682// --- algo.Smallstr25..Eq
17683inline bool algo::Smallstr25_Eq(algo::Smallstr25& lhs, algo::Smallstr25& rhs) {
17684 bool retval = true;
17685 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17686 return retval;
17687}
17688
17689// --- algo.Smallstr25..EqStrptr
17690inline bool algo::Smallstr25_EqStrptr(const algo::Smallstr25& lhs, const algo::strptr& rhs) {
17691 return algo::strptr_Eq(ch_Getary(lhs), rhs);
17692}
17693
17694inline bool algo::Smallstr3::operator ==(const algo::Smallstr3 &rhs) const {
17695 return algo::Smallstr3_Eq(const_cast<algo::Smallstr3&>(*this),const_cast<algo::Smallstr3&>(rhs));
17696}
17697
17698inline bool algo::Smallstr3::operator !=(const algo::Smallstr3 &rhs) const {
17699 return !algo::Smallstr3_Eq(const_cast<algo::Smallstr3&>(*this),const_cast<algo::Smallstr3&>(rhs));
17700}
17701
17702inline bool algo::Smallstr3::operator ==(const algo::strptr &rhs) const {
17703 return algo::Smallstr3_EqStrptr(const_cast<algo::Smallstr3&>(*this),rhs);
17704}
17705inline algo::Smallstr3::Smallstr3() {
17706 algo::Smallstr3_Init(*this);
17707}
17708
17709
17710// --- algo.Smallstr3.ch.Add
17711// Append character to string.
17712// If there is no space for an extra character, do nothing.
17713inline void algo::ch_Add(algo::Smallstr3& parent, char c) {
17714 if (parent.n_ch < 3) {
17715 parent.ch[parent.n_ch++] = c;
17716 }
17717}
17718
17719// --- algo.Smallstr3.ch.AddStrptr
17720// Append string to this string.
17721// If there is no space for an extra character, trim.
17722// If there is no space left, dump core in debug mode.
17723inline void algo::ch_AddStrptr(algo::Smallstr3& parent, algo::strptr str) {
17724 int n_new = str.n_elems;
17725 if (parent.n_ch + n_new > 3) {
17726 n_new = 3 - parent.n_ch;
17727 }
17728 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17729 parent.n_ch = u8(parent.n_ch + n_new);
17730}
17731
17732// --- algo.Smallstr3.ch.Getary
17733// Access string as array of chars
17734inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr3& parent) {
17735 int len = ch_N(parent);
17736 algo::aryptr<char> ret((char*)parent.ch, len);
17737 return ret;
17738}
17739
17740// --- algo.Smallstr3.ch.HashStrptr
17741inline u32 algo::Smallstr3_Hash(u32 prev, const algo::strptr &str) {
17742 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17743}
17744
17745// --- algo.Smallstr3.ch.Init
17746inline void algo::ch_Init(algo::Smallstr3 &parent) {
17747 parent.n_ch = 0;
17748}
17749
17750// --- algo.Smallstr3.ch.Max
17751// always return constant 3
17752inline int algo::ch_Max(algo::Smallstr3& parent) {
17753 (void)parent;
17754 return 3;
17755}
17756
17757// --- algo.Smallstr3.ch.N
17758inline int algo::ch_N(const algo::Smallstr3& parent) {
17759 u64 ret;
17760 ret = parent.n_ch;
17761 return int(ret);
17762}
17763
17764// --- algo.Smallstr3.ch.AssignStrptr
17765// Copy from strptr (operator=)
17766inline void algo::Smallstr3::operator =(const algo::strptr &str) {
17767 ch_SetStrptr(*this, str);
17768}
17769
17770// --- algo.Smallstr3.ch.Set
17771// Copy from same type
17772// Copy value from RHS.
17773inline void algo::Smallstr3::operator =(const algo::Smallstr3& parent) {
17774 memcpy(ch, parent.ch, parent.n_ch);
17775 n_ch = parent.n_ch;
17776}
17777
17778// --- algo.Smallstr3.ch.Ctor
17779inline algo::Smallstr3::Smallstr3(const algo::Smallstr3 &rhs) {
17780 operator =(rhs);
17781}
17782
17783// --- algo.Smallstr3.ch.CtorStrptr
17784inline algo::Smallstr3::Smallstr3(const algo::strptr &rhs) {
17785 ch_SetStrptr(*this, rhs);
17786}
17787
17788// --- algo.Smallstr3.ch.Cast
17789inline algo::Smallstr3::operator algo::strptr () const {
17790 return ch_Getary(*this);
17791}
17792
17793// --- algo.Smallstr3..Cmp
17794inline i32 algo::Smallstr3_Cmp(algo::Smallstr3& lhs, algo::Smallstr3& rhs) {
17795 i32 retval = 0;
17796 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17797 return retval;
17798}
17799
17800// --- algo.Smallstr3..Init
17801// Set all fields to initial values.
17802inline void algo::Smallstr3_Init(algo::Smallstr3& parent) {
17803 parent.n_ch = 0;
17804}
17805
17806// --- algo.Smallstr3..Eq
17807inline bool algo::Smallstr3_Eq(algo::Smallstr3& lhs, algo::Smallstr3& rhs) {
17808 bool retval = true;
17809 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17810 return retval;
17811}
17812
17813// --- algo.Smallstr3..EqStrptr
17814inline bool algo::Smallstr3_EqStrptr(const algo::Smallstr3& lhs, const algo::strptr& rhs) {
17815 return algo::strptr_Eq(ch_Getary(lhs), rhs);
17816}
17817
17818inline bool algo::Smallstr30::operator ==(const algo::Smallstr30 &rhs) const {
17819 return algo::Smallstr30_Eq(const_cast<algo::Smallstr30&>(*this),const_cast<algo::Smallstr30&>(rhs));
17820}
17821
17822inline bool algo::Smallstr30::operator !=(const algo::Smallstr30 &rhs) const {
17823 return !algo::Smallstr30_Eq(const_cast<algo::Smallstr30&>(*this),const_cast<algo::Smallstr30&>(rhs));
17824}
17825
17826inline bool algo::Smallstr30::operator ==(const algo::strptr &rhs) const {
17827 return algo::Smallstr30_EqStrptr(const_cast<algo::Smallstr30&>(*this),rhs);
17828}
17829
17830inline bool algo::Smallstr30::operator <(const algo::Smallstr30 &rhs) const {
17831 return algo::Smallstr30_Lt(const_cast<algo::Smallstr30&>(*this),const_cast<algo::Smallstr30&>(rhs));
17832}
17833
17834inline bool algo::Smallstr30::operator >(const algo::Smallstr30 &rhs) const {
17835 return rhs < *this;
17836}
17837
17838inline bool algo::Smallstr30::operator <=(const algo::Smallstr30 &rhs) const {
17839 return !(rhs < *this);
17840}
17841
17842inline bool algo::Smallstr30::operator >=(const algo::Smallstr30 &rhs) const {
17843 return !(*this < rhs);
17844}
17845inline algo::Smallstr30::Smallstr30() {
17846 algo::Smallstr30_Init(*this);
17847}
17848
17849
17850// --- algo.Smallstr30.ch.Add
17851// Append character to string.
17852// If there is no space for an extra character, do nothing.
17853inline void algo::ch_Add(algo::Smallstr30& parent, char c) {
17854 if (parent.n_ch < 30) {
17855 parent.ch[parent.n_ch++] = c;
17856 }
17857}
17858
17859// --- algo.Smallstr30.ch.AddStrptr
17860// Append string to this string.
17861// If there is no space for an extra character, trim.
17862// If there is no space left, dump core in debug mode.
17863inline void algo::ch_AddStrptr(algo::Smallstr30& parent, algo::strptr str) {
17864 int n_new = str.n_elems;
17865 if (parent.n_ch + n_new > 30) {
17866 n_new = 30 - parent.n_ch;
17867 }
17868 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
17869 parent.n_ch = u8(parent.n_ch + n_new);
17870}
17871
17872// --- algo.Smallstr30.ch.Getary
17873// Access string as array of chars
17874inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr30& parent) {
17875 int len = ch_N(parent);
17876 algo::aryptr<char> ret((char*)parent.ch, len);
17877 return ret;
17878}
17879
17880// --- algo.Smallstr30.ch.HashStrptr
17881inline u32 algo::Smallstr30_Hash(u32 prev, const algo::strptr &str) {
17882 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
17883}
17884
17885// --- algo.Smallstr30.ch.Init
17886inline void algo::ch_Init(algo::Smallstr30 &parent) {
17887 parent.n_ch = 0;
17888}
17889
17890// --- algo.Smallstr30.ch.Max
17891// always return constant 30
17892inline int algo::ch_Max(algo::Smallstr30& parent) {
17893 (void)parent;
17894 return 30;
17895}
17896
17897// --- algo.Smallstr30.ch.N
17898inline int algo::ch_N(const algo::Smallstr30& parent) {
17899 u64 ret;
17900 ret = parent.n_ch;
17901 return int(ret);
17902}
17903
17904// --- algo.Smallstr30.ch.AssignStrptr
17905// Copy from strptr (operator=)
17906inline void algo::Smallstr30::operator =(const algo::strptr &str) {
17907 ch_SetStrptr(*this, str);
17908}
17909
17910// --- algo.Smallstr30.ch.Set
17911// Copy from same type
17912// Copy value from RHS.
17913inline void algo::Smallstr30::operator =(const algo::Smallstr30& parent) {
17914 memcpy(ch, parent.ch, parent.n_ch);
17915 n_ch = parent.n_ch;
17916}
17917
17918// --- algo.Smallstr30.ch.Ctor
17919inline algo::Smallstr30::Smallstr30(const algo::Smallstr30 &rhs) {
17920 operator =(rhs);
17921}
17922
17923// --- algo.Smallstr30.ch.CtorStrptr
17924inline algo::Smallstr30::Smallstr30(const algo::strptr &rhs) {
17925 ch_SetStrptr(*this, rhs);
17926}
17927
17928// --- algo.Smallstr30.ch.Cast
17929inline algo::Smallstr30::operator algo::strptr () const {
17930 return ch_Getary(*this);
17931}
17932
17933// --- algo.Smallstr30..Lt
17934inline bool algo::Smallstr30_Lt(algo::Smallstr30& lhs, algo::Smallstr30& rhs) {
17935 return algo::strptr_Lt(ch_Getary(lhs), ch_Getary(rhs));
17936}
17937
17938// --- algo.Smallstr30..Cmp
17939inline i32 algo::Smallstr30_Cmp(algo::Smallstr30& lhs, algo::Smallstr30& rhs) {
17940 i32 retval = 0;
17941 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
17942 return retval;
17943}
17944
17945// --- algo.Smallstr30..Init
17946// Set all fields to initial values.
17947inline void algo::Smallstr30_Init(algo::Smallstr30& parent) {
17948 parent.n_ch = 0;
17949}
17950
17951// --- algo.Smallstr30..Eq
17952inline bool algo::Smallstr30_Eq(algo::Smallstr30& lhs, algo::Smallstr30& rhs) {
17953 bool retval = true;
17954 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
17955 return retval;
17956}
17957
17958// --- algo.Smallstr30..Update
17959// Set value. Return true if new value is different from old value.
17960inline bool algo::Smallstr30_Update(algo::Smallstr30 &lhs, algo::Smallstr30& rhs) {
17961 bool ret = !Smallstr30_Eq(lhs, rhs); // compare values
17962 if (ret) {
17963 lhs = rhs; // update
17964 }
17965 return ret;
17966}
17967
17968// --- algo.Smallstr30..EqStrptr
17969inline bool algo::Smallstr30_EqStrptr(const algo::Smallstr30& lhs, const algo::strptr& rhs) {
17970 return algo::strptr_Eq(ch_Getary(lhs), rhs);
17971}
17972
17973inline bool algo::Smallstr32::operator ==(const algo::Smallstr32 &rhs) const {
17974 return algo::Smallstr32_Eq(const_cast<algo::Smallstr32&>(*this),const_cast<algo::Smallstr32&>(rhs));
17975}
17976
17977inline bool algo::Smallstr32::operator !=(const algo::Smallstr32 &rhs) const {
17978 return !algo::Smallstr32_Eq(const_cast<algo::Smallstr32&>(*this),const_cast<algo::Smallstr32&>(rhs));
17979}
17980
17981inline bool algo::Smallstr32::operator ==(const algo::strptr &rhs) const {
17982 return algo::Smallstr32_EqStrptr(const_cast<algo::Smallstr32&>(*this),rhs);
17983}
17984inline algo::Smallstr32::Smallstr32() {
17985 algo::Smallstr32_Init(*this);
17986}
17987
17988
17989// --- algo.Smallstr32.ch.Add
17990// Append character to string.
17991// If there is no space for an extra character, do nothing.
17992inline void algo::ch_Add(algo::Smallstr32& parent, char c) {
17993 if (parent.n_ch < 32) {
17994 parent.ch[parent.n_ch++] = c;
17995 }
17996}
17997
17998// --- algo.Smallstr32.ch.AddStrptr
17999// Append string to this string.
18000// If there is no space for an extra character, trim.
18001// If there is no space left, dump core in debug mode.
18002inline void algo::ch_AddStrptr(algo::Smallstr32& parent, algo::strptr str) {
18003 int n_new = str.n_elems;
18004 if (parent.n_ch + n_new > 32) {
18005 n_new = 32 - parent.n_ch;
18006 }
18007 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
18008 parent.n_ch = u8(parent.n_ch + n_new);
18009}
18010
18011// --- algo.Smallstr32.ch.Getary
18012// Access string as array of chars
18013inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr32& parent) {
18014 int len = ch_N(parent);
18015 algo::aryptr<char> ret((char*)parent.ch, len);
18016 return ret;
18017}
18018
18019// --- algo.Smallstr32.ch.HashStrptr
18020inline u32 algo::Smallstr32_Hash(u32 prev, const algo::strptr &str) {
18021 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
18022}
18023
18024// --- algo.Smallstr32.ch.Init
18025inline void algo::ch_Init(algo::Smallstr32 &parent) {
18026 parent.n_ch = 0;
18027}
18028
18029// --- algo.Smallstr32.ch.Max
18030// always return constant 32
18031inline int algo::ch_Max(algo::Smallstr32& parent) {
18032 (void)parent;
18033 return 32;
18034}
18035
18036// --- algo.Smallstr32.ch.N
18037inline int algo::ch_N(const algo::Smallstr32& parent) {
18038 u64 ret;
18039 ret = parent.n_ch;
18040 return int(ret);
18041}
18042
18043// --- algo.Smallstr32.ch.AssignStrptr
18044// Copy from strptr (operator=)
18045inline void algo::Smallstr32::operator =(const algo::strptr &str) {
18046 ch_SetStrptr(*this, str);
18047}
18048
18049// --- algo.Smallstr32.ch.Set
18050// Copy from same type
18051// Copy value from RHS.
18052inline void algo::Smallstr32::operator =(const algo::Smallstr32& parent) {
18053 memcpy(ch, parent.ch, parent.n_ch);
18054 n_ch = parent.n_ch;
18055}
18056
18057// --- algo.Smallstr32.ch.Ctor
18058inline algo::Smallstr32::Smallstr32(const algo::Smallstr32 &rhs) {
18059 operator =(rhs);
18060}
18061
18062// --- algo.Smallstr32.ch.CtorStrptr
18063inline algo::Smallstr32::Smallstr32(const algo::strptr &rhs) {
18064 ch_SetStrptr(*this, rhs);
18065}
18066
18067// --- algo.Smallstr32.ch.Cast
18068inline algo::Smallstr32::operator algo::strptr () const {
18069 return ch_Getary(*this);
18070}
18071
18072// --- algo.Smallstr32..Cmp
18073inline i32 algo::Smallstr32_Cmp(algo::Smallstr32& lhs, algo::Smallstr32& rhs) {
18074 i32 retval = 0;
18075 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
18076 return retval;
18077}
18078
18079// --- algo.Smallstr32..Init
18080// Set all fields to initial values.
18081inline void algo::Smallstr32_Init(algo::Smallstr32& parent) {
18082 parent.n_ch = 0;
18083}
18084
18085// --- algo.Smallstr32..Eq
18086inline bool algo::Smallstr32_Eq(algo::Smallstr32& lhs, algo::Smallstr32& rhs) {
18087 bool retval = true;
18088 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
18089 return retval;
18090}
18091
18092// --- algo.Smallstr32..EqStrptr
18093inline bool algo::Smallstr32_EqStrptr(const algo::Smallstr32& lhs, const algo::strptr& rhs) {
18094 return algo::strptr_Eq(ch_Getary(lhs), rhs);
18095}
18096
18097inline bool algo::Smallstr4::operator ==(const algo::Smallstr4 &rhs) const {
18098 return algo::Smallstr4_Eq(const_cast<algo::Smallstr4&>(*this),const_cast<algo::Smallstr4&>(rhs));
18099}
18100
18101inline bool algo::Smallstr4::operator !=(const algo::Smallstr4 &rhs) const {
18102 return !algo::Smallstr4_Eq(const_cast<algo::Smallstr4&>(*this),const_cast<algo::Smallstr4&>(rhs));
18103}
18104
18105inline bool algo::Smallstr4::operator ==(const algo::strptr &rhs) const {
18106 return algo::Smallstr4_EqStrptr(const_cast<algo::Smallstr4&>(*this),rhs);
18107}
18108inline algo::Smallstr4::Smallstr4() {
18109 algo::Smallstr4_Init(*this);
18110}
18111
18112
18113// --- algo.Smallstr4.ch.Add
18114// Append character to string.
18115// If there is no space for an extra character, do nothing.
18116inline void algo::ch_Add(algo::Smallstr4& parent, char c) {
18117 if (parent.n_ch < 4) {
18118 parent.ch[parent.n_ch++] = c;
18119 }
18120}
18121
18122// --- algo.Smallstr4.ch.AddStrptr
18123// Append string to this string.
18124// If there is no space for an extra character, trim.
18125// If there is no space left, dump core in debug mode.
18126inline void algo::ch_AddStrptr(algo::Smallstr4& parent, algo::strptr str) {
18127 int n_new = str.n_elems;
18128 if (parent.n_ch + n_new > 4) {
18129 n_new = 4 - parent.n_ch;
18130 }
18131 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
18132 parent.n_ch = u8(parent.n_ch + n_new);
18133}
18134
18135// --- algo.Smallstr4.ch.Getary
18136// Access string as array of chars
18137inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr4& parent) {
18138 int len = ch_N(parent);
18139 algo::aryptr<char> ret((char*)parent.ch, len);
18140 return ret;
18141}
18142
18143// --- algo.Smallstr4.ch.HashStrptr
18144inline u32 algo::Smallstr4_Hash(u32 prev, const algo::strptr &str) {
18145 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
18146}
18147
18148// --- algo.Smallstr4.ch.Init
18149inline void algo::ch_Init(algo::Smallstr4 &parent) {
18150 parent.n_ch = 0;
18151}
18152
18153// --- algo.Smallstr4.ch.Max
18154// always return constant 4
18155inline int algo::ch_Max(algo::Smallstr4& parent) {
18156 (void)parent;
18157 return 4;
18158}
18159
18160// --- algo.Smallstr4.ch.N
18161inline int algo::ch_N(const algo::Smallstr4& parent) {
18162 u64 ret;
18163 ret = parent.n_ch;
18164 return int(ret);
18165}
18166
18167// --- algo.Smallstr4.ch.AssignStrptr
18168// Copy from strptr (operator=)
18169inline void algo::Smallstr4::operator =(const algo::strptr &str) {
18170 ch_SetStrptr(*this, str);
18171}
18172
18173// --- algo.Smallstr4.ch.Set
18174// Copy from same type
18175// Copy value from RHS.
18176inline void algo::Smallstr4::operator =(const algo::Smallstr4& parent) {
18177 memcpy(ch, parent.ch, parent.n_ch);
18178 n_ch = parent.n_ch;
18179}
18180
18181// --- algo.Smallstr4.ch.Ctor
18182inline algo::Smallstr4::Smallstr4(const algo::Smallstr4 &rhs) {
18183 operator =(rhs);
18184}
18185
18186// --- algo.Smallstr4.ch.CtorStrptr
18187inline algo::Smallstr4::Smallstr4(const algo::strptr &rhs) {
18188 ch_SetStrptr(*this, rhs);
18189}
18190
18191// --- algo.Smallstr4.ch.Cast
18192inline algo::Smallstr4::operator algo::strptr () const {
18193 return ch_Getary(*this);
18194}
18195
18196// --- algo.Smallstr4..Cmp
18197inline i32 algo::Smallstr4_Cmp(algo::Smallstr4& lhs, algo::Smallstr4& rhs) {
18198 i32 retval = 0;
18199 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
18200 return retval;
18201}
18202
18203// --- algo.Smallstr4..Init
18204// Set all fields to initial values.
18205inline void algo::Smallstr4_Init(algo::Smallstr4& parent) {
18206 parent.n_ch = 0;
18207}
18208
18209// --- algo.Smallstr4..Eq
18210inline bool algo::Smallstr4_Eq(algo::Smallstr4& lhs, algo::Smallstr4& rhs) {
18211 bool retval = true;
18212 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
18213 return retval;
18214}
18215
18216// --- algo.Smallstr4..EqStrptr
18217inline bool algo::Smallstr4_EqStrptr(const algo::Smallstr4& lhs, const algo::strptr& rhs) {
18218 return algo::strptr_Eq(ch_Getary(lhs), rhs);
18219}
18220
18221inline bool algo::Smallstr40::operator ==(const algo::Smallstr40 &rhs) const {
18222 return algo::Smallstr40_Eq(const_cast<algo::Smallstr40&>(*this),const_cast<algo::Smallstr40&>(rhs));
18223}
18224
18225inline bool algo::Smallstr40::operator !=(const algo::Smallstr40 &rhs) const {
18226 return !algo::Smallstr40_Eq(const_cast<algo::Smallstr40&>(*this),const_cast<algo::Smallstr40&>(rhs));
18227}
18228
18229inline bool algo::Smallstr40::operator ==(const algo::strptr &rhs) const {
18230 return algo::Smallstr40_EqStrptr(const_cast<algo::Smallstr40&>(*this),rhs);
18231}
18232inline algo::Smallstr40::Smallstr40() {
18233 algo::Smallstr40_Init(*this);
18234}
18235
18236
18237// --- algo.Smallstr40.ch.Add
18238// Append character to string.
18239// If there is no space for an extra character, do nothing.
18240inline void algo::ch_Add(algo::Smallstr40& parent, char c) {
18241 if (parent.n_ch < 40) {
18242 parent.ch[parent.n_ch++] = c;
18243 }
18244}
18245
18246// --- algo.Smallstr40.ch.AddStrptr
18247// Append string to this string.
18248// If there is no space for an extra character, trim.
18249// If there is no space left, dump core in debug mode.
18250inline void algo::ch_AddStrptr(algo::Smallstr40& parent, algo::strptr str) {
18251 int n_new = str.n_elems;
18252 if (parent.n_ch + n_new > 40) {
18253 n_new = 40 - parent.n_ch;
18254 }
18255 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
18256 parent.n_ch = u8(parent.n_ch + n_new);
18257}
18258
18259// --- algo.Smallstr40.ch.Getary
18260// Access string as array of chars
18261inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr40& parent) {
18262 int len = ch_N(parent);
18263 algo::aryptr<char> ret((char*)parent.ch, len);
18264 return ret;
18265}
18266
18267// --- algo.Smallstr40.ch.HashStrptr
18268inline u32 algo::Smallstr40_Hash(u32 prev, const algo::strptr &str) {
18269 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
18270}
18271
18272// --- algo.Smallstr40.ch.Init
18273inline void algo::ch_Init(algo::Smallstr40 &parent) {
18274 parent.n_ch = 0;
18275}
18276
18277// --- algo.Smallstr40.ch.Max
18278// always return constant 40
18279inline int algo::ch_Max(algo::Smallstr40& parent) {
18280 (void)parent;
18281 return 40;
18282}
18283
18284// --- algo.Smallstr40.ch.N
18285inline int algo::ch_N(const algo::Smallstr40& parent) {
18286 u64 ret;
18287 ret = parent.n_ch;
18288 return int(ret);
18289}
18290
18291// --- algo.Smallstr40.ch.AssignStrptr
18292// Copy from strptr (operator=)
18293inline void algo::Smallstr40::operator =(const algo::strptr &str) {
18294 ch_SetStrptr(*this, str);
18295}
18296
18297// --- algo.Smallstr40.ch.Set
18298// Copy from same type
18299// Copy value from RHS.
18300inline void algo::Smallstr40::operator =(const algo::Smallstr40& parent) {
18301 memcpy(ch, parent.ch, parent.n_ch);
18302 n_ch = parent.n_ch;
18303}
18304
18305// --- algo.Smallstr40.ch.Ctor
18306inline algo::Smallstr40::Smallstr40(const algo::Smallstr40 &rhs) {
18307 operator =(rhs);
18308}
18309
18310// --- algo.Smallstr40.ch.CtorStrptr
18311inline algo::Smallstr40::Smallstr40(const algo::strptr &rhs) {
18312 ch_SetStrptr(*this, rhs);
18313}
18314
18315// --- algo.Smallstr40.ch.Cast
18316inline algo::Smallstr40::operator algo::strptr () const {
18317 return ch_Getary(*this);
18318}
18319
18320// --- algo.Smallstr40..Cmp
18321inline i32 algo::Smallstr40_Cmp(algo::Smallstr40& lhs, algo::Smallstr40& rhs) {
18322 i32 retval = 0;
18323 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
18324 return retval;
18325}
18326
18327// --- algo.Smallstr40..Init
18328// Set all fields to initial values.
18329inline void algo::Smallstr40_Init(algo::Smallstr40& parent) {
18330 parent.n_ch = 0;
18331}
18332
18333// --- algo.Smallstr40..Eq
18334inline bool algo::Smallstr40_Eq(algo::Smallstr40& lhs, algo::Smallstr40& rhs) {
18335 bool retval = true;
18336 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
18337 return retval;
18338}
18339
18340// --- algo.Smallstr40..EqStrptr
18341inline bool algo::Smallstr40_EqStrptr(const algo::Smallstr40& lhs, const algo::strptr& rhs) {
18342 return algo::strptr_Eq(ch_Getary(lhs), rhs);
18343}
18344
18345inline bool algo::Smallstr5::operator ==(const algo::Smallstr5 &rhs) const {
18346 return algo::Smallstr5_Eq(const_cast<algo::Smallstr5&>(*this),const_cast<algo::Smallstr5&>(rhs));
18347}
18348
18349inline bool algo::Smallstr5::operator !=(const algo::Smallstr5 &rhs) const {
18350 return !algo::Smallstr5_Eq(const_cast<algo::Smallstr5&>(*this),const_cast<algo::Smallstr5&>(rhs));
18351}
18352
18353inline bool algo::Smallstr5::operator ==(const algo::strptr &rhs) const {
18354 return algo::Smallstr5_EqStrptr(const_cast<algo::Smallstr5&>(*this),rhs);
18355}
18356inline algo::Smallstr5::Smallstr5() {
18357 algo::Smallstr5_Init(*this);
18358}
18359
18360
18361// --- algo.Smallstr5.ch.Add
18362// Append character to string.
18363// If there is no space for an extra character, do nothing.
18364inline void algo::ch_Add(algo::Smallstr5& parent, char c) {
18365 if (parent.n_ch < 5) {
18366 parent.ch[parent.n_ch++] = c;
18367 }
18368}
18369
18370// --- algo.Smallstr5.ch.AddStrptr
18371// Append string to this string.
18372// If there is no space for an extra character, trim.
18373// If there is no space left, dump core in debug mode.
18374inline void algo::ch_AddStrptr(algo::Smallstr5& parent, algo::strptr str) {
18375 int n_new = str.n_elems;
18376 if (parent.n_ch + n_new > 5) {
18377 n_new = 5 - parent.n_ch;
18378 }
18379 memcpy(parent.ch + parent.n_ch, str.elems, n_new);
18380 parent.n_ch = u8(parent.n_ch + n_new);
18381}
18382
18383// --- algo.Smallstr5.ch.Getary
18384// Access string as array of chars
18385inline algo::aryptr<char> algo::ch_Getary(const algo::Smallstr5& parent) {
18386 int len = ch_N(parent);
18387 algo::aryptr<char> ret((char*)parent.ch, len);
18388 return ret;
18389}
18390
18391// --- algo.Smallstr5.ch.HashStrptr
18392inline u32 algo::Smallstr5_Hash(u32 prev, const algo::strptr &str) {
18393 return algo::CRC32Step(prev, (u8*)str.elems, str.n_elems);
18394}
18395
18396// --- algo.Smallstr5.ch.Init
18397inline void algo::ch_Init(algo::Smallstr5 &parent) {
18398 parent.n_ch = 0;
18399}
18400
18401// --- algo.Smallstr5.ch.Max
18402// always return constant 5
18403inline int algo::ch_Max(algo::Smallstr5& parent) {
18404 (void)parent;
18405 return 5;
18406}
18407
18408// --- algo.Smallstr5.ch.N
18409inline int algo::ch_N(const algo::Smallstr5& parent) {
18410 u64 ret;
18411 ret = parent.n_ch;
18412 return int(ret);
18413}
18414
18415// --- algo.Smallstr5.ch.AssignStrptr
18416// Copy from strptr (operator=)
18417inline void algo::Smallstr5::operator =(const algo::strptr &str) {
18418 ch_SetStrptr(*this, str);
18419}
18420
18421// --- algo.Smallstr5.ch.Set
18422// Copy from same type
18423// Copy value from RHS.
18424inline void algo::Smallstr5::operator =(const algo::Smallstr5& parent) {
18425 memcpy(ch, parent.ch, parent.n_ch);
18426 n_ch = parent.n_ch;
18427}
18428
18429// --- algo.Smallstr5.ch.Ctor
18430inline algo::Smallstr5::Smallstr5(const algo::Smallstr5 &rhs) {
18431 operator =(rhs);
18432}
18433
18434// --- algo.Smallstr5.ch.CtorStrptr
18435inline algo::Smallstr5::Smallstr5(const algo::strptr &rhs) {
18436 ch_SetStrptr(*this, rhs);
18437}
18438
18439// --- algo.Smallstr5.ch.Cast
18440inline algo::Smallstr5::operator algo::strptr () const {
18441 return ch_Getary(*this);
18442}
18443
18444// --- algo.Smallstr5..Cmp
18445inline i32 algo::Smallstr5_Cmp(algo::Smallstr5& lhs, algo::Smallstr5& rhs) {
18446 i32 retval = 0;
18447 retval = algo::strptr_Cmp(ch_Getary(lhs), ch_Getary(rhs));
18448 return retval;
18449}
18450
18451// --- algo.Smallstr5..Init
18452// Set all fields to initial values.
18453inline void algo::Smallstr5_Init(algo::Smallstr5& parent) {
18454 parent.n_ch = 0;
18455}
18456
18457// --- algo.Smallstr5..Eq
18458inline bool algo::Smallstr5_Eq(algo::Smallstr5& lhs, algo::Smallstr5& rhs) {
18459 bool retval = true;
18460 retval = algo::strptr_Eq(ch_Getary(lhs), ch_Getary(rhs));
18461 return retval;
18462}
18463
18464// --- algo.Smallstr5..EqStrptr
18465inline bool algo::Smallstr5_EqStrptr(const algo::Smallstr5& lhs, const algo::strptr& rhs) {
18466 return algo::strptr_Eq(ch_Getary(lhs), rhs);
18467}
18468inline algo::StringAry::StringAry() {
18469 algo::StringAry_Init(*this);
18470}
18471
18472inline algo::StringAry::~StringAry() {
18473 algo::StringAry_Uninit(*this);
18474}
18475
18476
18477// --- algo.StringAry.ary.EmptyQ
18478// Return true if index is empty
18479inline bool algo::ary_EmptyQ(algo::StringAry& parent) {
18480 return parent.ary_n == 0;
18481}
18482
18483// --- algo.StringAry.ary.Find
18484// Look up row by row id. Return NULL if out of range
18485inline algo::cstring* algo::ary_Find(algo::StringAry& parent, u64 t) {
18486 u64 idx = t;
18487 u64 lim = parent.ary_n;
18488 if (idx >= lim) return NULL;
18489 return parent.ary_elems + idx;
18490}
18491
18492// --- algo.StringAry.ary.Getary
18493// Return array pointer by value
18494inline algo::aryptr<algo::cstring> algo::ary_Getary(const algo::StringAry& parent) {
18495 return algo::aryptr<algo::cstring>(parent.ary_elems, parent.ary_n);
18496}
18497
18498// --- algo.StringAry.ary.Last
18499// Return pointer to last element of array, or NULL if array is empty
18500inline algo::cstring* algo::ary_Last(algo::StringAry& parent) {
18501 return ary_Find(parent, u64(parent.ary_n-1));
18502}
18503
18504// --- algo.StringAry.ary.Max
18505// Return max. number of items in the array
18506inline i32 algo::ary_Max(algo::StringAry& parent) {
18507 (void)parent;
18508 return parent.ary_max;
18509}
18510
18511// --- algo.StringAry.ary.N
18512// Return number of items in the array
18513inline i32 algo::ary_N(const algo::StringAry& parent) {
18514 return parent.ary_n;
18515}
18516
18517// --- algo.StringAry.ary.Reserve
18518// Make sure N *more* elements will fit in array. Process dies if out of memory
18519inline void algo::ary_Reserve(algo::StringAry& parent, int n) {
18520 u32 new_n = parent.ary_n + n;
18521 if (UNLIKELY(new_n > parent.ary_max)) {
18522 ary_AbsReserve(parent, new_n);
18523 }
18524}
18525
18526// --- algo.StringAry.ary.qFind
18527// 'quick' Access row by row id. No bounds checking.
18528inline algo::cstring& algo::ary_qFind(algo::StringAry& parent, u64 t) {
18529 return parent.ary_elems[t];
18530}
18531
18532// --- algo.StringAry.ary.qLast
18533// Return reference to last element of array. No bounds checking
18534inline algo::cstring& algo::ary_qLast(algo::StringAry& parent) {
18535 return ary_qFind(parent, u64(parent.ary_n-1));
18536}
18537
18538// --- algo.StringAry.ary.rowid_Get
18539// Return row id of specified element
18540inline u64 algo::ary_rowid_Get(algo::StringAry& parent, algo::cstring &elem) {
18541 u64 id = &elem - parent.ary_elems;
18542 return u64(id);
18543}
18544
18545// --- algo.StringAry.ary_curs.Next
18546// proceed to next item
18547inline void algo::StringAry_ary_curs_Next(StringAry_ary_curs &curs) {
18548 curs.index++;
18549}
18550
18551// --- algo.StringAry.ary_curs.Reset
18552inline void algo::StringAry_ary_curs_Reset(StringAry_ary_curs &curs, algo::StringAry &parent) {
18553 curs.elems = parent.ary_elems;
18554 curs.n_elems = parent.ary_n;
18555 curs.index = 0;
18556}
18557
18558// --- algo.StringAry.ary_curs.ValidQ
18559// cursor points to valid item
18560inline bool algo::StringAry_ary_curs_ValidQ(StringAry_ary_curs &curs) {
18561 return curs.index < curs.n_elems;
18562}
18563
18564// --- algo.StringAry.ary_curs.Access
18565// item access
18566inline algo::cstring& algo::StringAry_ary_curs_Access(StringAry_ary_curs &curs) {
18567 return curs.elems[curs.index];
18568}
18569
18570// --- algo.StringAry..Init
18571// Set all fields to initial values.
18572inline void algo::StringAry_Init(algo::StringAry& parent) {
18573 parent.ary_elems = 0; // (algo.StringAry.ary)
18574 parent.ary_n = 0; // (algo.StringAry.ary)
18575 parent.ary_max = 0; // (algo.StringAry.ary)
18576}
18577inline algo::TermStyle::TermStyle(u32 in_value)
18578 : value(in_value)
18579{
18580}
18581inline algo::TermStyle::TermStyle(algo_TermStyleEnum arg) { this->value = u32(arg); }
18582inline algo::TermStyle::TermStyle() {
18583 algo::TermStyle_Init(*this);
18584}
18585
18586
18587// --- algo.TermStyle.value.GetEnum
18588// Get value of field as enum type
18589inline algo_TermStyleEnum algo::value_GetEnum(const algo::TermStyle& parent) {
18590 return algo_TermStyleEnum(parent.value);
18591}
18592
18593// --- algo.TermStyle.value.SetEnum
18594// Set value of field from enum type.
18595inline void algo::value_SetEnum(algo::TermStyle& parent, algo_TermStyleEnum rhs) {
18596 parent.value = u32(rhs);
18597}
18598
18599// --- algo.TermStyle.value.Cast
18600inline algo::TermStyle::operator algo_TermStyleEnum () const {
18601 return algo_TermStyleEnum((*this).value);
18602}
18603
18604// --- algo.TermStyle..Init
18605// Set all fields to initial values.
18606inline void algo::TermStyle_Init(algo::TermStyle& parent) {
18607 parent.value = u32(0);
18608}
18609inline algo::TextJust::TextJust(i32 in_value)
18610 : value(in_value)
18611{
18612}
18613inline algo::TextJust::TextJust(algo_TextJustEnum arg) { this->value = i32(arg); }
18614inline algo::TextJust::TextJust() {
18615 algo::TextJust_Init(*this);
18616}
18617
18618
18619// --- algo.TextJust.value.GetEnum
18620// Get value of field as enum type
18621inline algo_TextJustEnum algo::value_GetEnum(const algo::TextJust& parent) {
18622 return algo_TextJustEnum(parent.value);
18623}
18624
18625// --- algo.TextJust.value.SetEnum
18626// Set value of field from enum type.
18627inline void algo::value_SetEnum(algo::TextJust& parent, algo_TextJustEnum rhs) {
18628 parent.value = i32(rhs);
18629}
18630
18631// --- algo.TextJust.value.Cast
18632inline algo::TextJust::operator algo_TextJustEnum () const {
18633 return algo_TextJustEnum((*this).value);
18634}
18635
18636// --- algo.TextJust..Init
18637// Set all fields to initial values.
18638inline void algo::TextJust_Init(algo::TextJust& parent) {
18639 parent.value = i32(0);
18640}
18641inline algo::TstampCache::TstampCache() {
18642 algo::TstampCache_Init(*this);
18643}
18644
18645inline algo::Tuple::Tuple() {
18646 algo::Tuple_Init(*this);
18647}
18648
18649inline algo::Tuple::~Tuple() {
18650 algo::Tuple_Uninit(*this);
18651}
18652
18653
18654// --- algo.Tuple.attrs.EmptyQ
18655// Return true if index is empty
18656inline bool algo::attrs_EmptyQ(algo::Tuple& parent) {
18657 return parent.attrs_n == 0;
18658}
18659
18660// --- algo.Tuple.attrs.Find
18661// Look up row by row id. Return NULL if out of range
18662inline algo::Attr* algo::attrs_Find(algo::Tuple& parent, u64 t) {
18663 u64 idx = t;
18664 u64 lim = parent.attrs_n;
18665 if (idx >= lim) return NULL;
18666 return parent.attrs_elems + idx;
18667}
18668
18669// --- algo.Tuple.attrs.Getary
18670// Return array pointer by value
18671inline algo::aryptr<algo::Attr> algo::attrs_Getary(const algo::Tuple& parent) {
18672 return algo::aryptr<algo::Attr>(parent.attrs_elems, parent.attrs_n);
18673}
18674
18675// --- algo.Tuple.attrs.Last
18676// Return pointer to last element of array, or NULL if array is empty
18677inline algo::Attr* algo::attrs_Last(algo::Tuple& parent) {
18678 return attrs_Find(parent, u64(parent.attrs_n-1));
18679}
18680
18681// --- algo.Tuple.attrs.Max
18682// Return max. number of items in the array
18683inline i32 algo::attrs_Max(algo::Tuple& parent) {
18684 (void)parent;
18685 return parent.attrs_max;
18686}
18687
18688// --- algo.Tuple.attrs.N
18689// Return number of items in the array
18690inline i32 algo::attrs_N(const algo::Tuple& parent) {
18691 return parent.attrs_n;
18692}
18693
18694// --- algo.Tuple.attrs.Reserve
18695// Make sure N *more* elements will fit in array. Process dies if out of memory
18696inline void algo::attrs_Reserve(algo::Tuple& parent, int n) {
18697 u32 new_n = parent.attrs_n + n;
18698 if (UNLIKELY(new_n > parent.attrs_max)) {
18699 attrs_AbsReserve(parent, new_n);
18700 }
18701}
18702
18703// --- algo.Tuple.attrs.qFind
18704// 'quick' Access row by row id. No bounds checking.
18705inline algo::Attr& algo::attrs_qFind(algo::Tuple& parent, u64 t) {
18706 return parent.attrs_elems[t];
18707}
18708
18709// --- algo.Tuple.attrs.qLast
18710// Return reference to last element of array. No bounds checking
18711inline algo::Attr& algo::attrs_qLast(algo::Tuple& parent) {
18712 return attrs_qFind(parent, u64(parent.attrs_n-1));
18713}
18714
18715// --- algo.Tuple.attrs.rowid_Get
18716// Return row id of specified element
18717inline u64 algo::attrs_rowid_Get(algo::Tuple& parent, algo::Attr &elem) {
18718 u64 id = &elem - parent.attrs_elems;
18719 return u64(id);
18720}
18721
18722// --- algo.Tuple.attrs_curs.Next
18723// proceed to next item
18724inline void algo::Tuple_attrs_curs_Next(Tuple_attrs_curs &curs) {
18725 curs.index++;
18726}
18727
18728// --- algo.Tuple.attrs_curs.Reset
18729inline void algo::Tuple_attrs_curs_Reset(Tuple_attrs_curs &curs, algo::Tuple &parent) {
18730 curs.elems = parent.attrs_elems;
18731 curs.n_elems = parent.attrs_n;
18732 curs.index = 0;
18733}
18734
18735// --- algo.Tuple.attrs_curs.ValidQ
18736// cursor points to valid item
18737inline bool algo::Tuple_attrs_curs_ValidQ(Tuple_attrs_curs &curs) {
18738 return curs.index < curs.n_elems;
18739}
18740
18741// --- algo.Tuple.attrs_curs.Access
18742// item access
18743inline algo::Attr& algo::Tuple_attrs_curs_Access(Tuple_attrs_curs &curs) {
18744 return curs.elems[curs.index];
18745}
18746
18747// --- algo.Tuple..Init
18748// Set all fields to initial values.
18749inline void algo::Tuple_Init(algo::Tuple& parent) {
18750 parent.attrs_elems = 0; // (algo.Tuple.attrs)
18751 parent.attrs_n = 0; // (algo.Tuple.attrs)
18752 parent.attrs_max = 0; // (algo.Tuple.attrs)
18753}
18754inline algo::U16Dec2::U16Dec2(u16 in_value)
18755 : value(in_value)
18756{
18757}
18758inline algo::U16Dec2::U16Dec2() {
18759 algo::U16Dec2_Init(*this);
18760}
18761
18762
18763// --- algo.U16Dec2.value.qSetDouble
18764// Set value of field value.
18765// The value is rounded to the nearest integer.
18766// This ensures that truncation of a near-integer value does not occur.
18767// Example: 1.3 cannot be represented exactly as a double, the actual
18768// stored value will be 1.29999999. when we apply C truncation,
18769// we want to end up with 1.3, not 1.2.
18770inline void algo::value_qSetDouble(algo::U16Dec2& parent, double val) {
18771 double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
18772 // set underlying field.
18773 parent.value = intval;
18774}
18775
18776// --- algo.U16Dec2.value.GetDouble
18777inline double algo::value_GetDouble(const algo::U16Dec2& parent) {
18778 double ret;
18779 ret = parent.value / double(100);
18780 return ret;
18781}
18782
18783// --- algo.U16Dec2.value.GetInt
18784// Return integer portion (divide number by 100)
18785inline u16 algo::value_GetInt(const algo::U16Dec2& parent) {
18786 u16 ret;
18787 ret = parent.value / 100;
18788 return ret;
18789}
18790
18791// --- algo.U16Dec2.value.GetScale
18792// Return constant 100
18793inline u16 algo::U16Dec2_GetScale() {
18794 return 100;
18795}
18796
18797// --- algo.U16Dec2.value.Cast
18798inline algo::U16Dec2::operator u16 () const {
18799 return u16((*this).value);
18800}
18801
18802// --- algo.U16Dec2..Hash
18803inline u32 algo::U16Dec2_Hash(u32 prev, algo::U16Dec2 rhs) {
18804 prev = u16_Hash(prev, rhs.value);
18805 return prev;
18806}
18807
18808// --- algo.U16Dec2..Init
18809// Set all fields to initial values.
18810inline void algo::U16Dec2_Init(algo::U16Dec2& parent) {
18811 parent.value = u16(0);
18812}
18813inline algo::U32Dec1::U32Dec1(u32 in_value)
18814 : value(in_value)
18815{
18816}
18817inline algo::U32Dec1::U32Dec1() {
18818 algo::U32Dec1_Init(*this);
18819}
18820
18821
18822// --- algo.U32Dec1.value.qSetDouble
18823// Set value of field value.
18824// The value is rounded to the nearest integer.
18825// This ensures that truncation of a near-integer value does not occur.
18826// Example: 1.3 cannot be represented exactly as a double, the actual
18827// stored value will be 1.29999999. when we apply C truncation,
18828// we want to end up with 1.3, not 1.2.
18829inline void algo::value_qSetDouble(algo::U32Dec1& parent, double val) {
18830 double intval = val * 10 + (val > 0 ? 0.5 : -0.5);
18831 // set underlying field.
18832 parent.value = intval;
18833}
18834
18835// --- algo.U32Dec1.value.GetDouble
18836inline double algo::value_GetDouble(const algo::U32Dec1& parent) {
18837 double ret;
18838 ret = parent.value / double(10);
18839 return ret;
18840}
18841
18842// --- algo.U32Dec1.value.GetInt
18843// Return integer portion (divide number by 10)
18844inline u32 algo::value_GetInt(const algo::U32Dec1& parent) {
18845 u32 ret;
18846 ret = parent.value / 10;
18847 return ret;
18848}
18849
18850// --- algo.U32Dec1.value.GetScale
18851// Return constant 10
18852inline u32 algo::U32Dec1_GetScale() {
18853 return 10;
18854}
18855
18856// --- algo.U32Dec1.value.Cast
18857inline algo::U32Dec1::operator u32 () const {
18858 return u32((*this).value);
18859}
18860
18861// --- algo.U32Dec1..Hash
18862inline u32 algo::U32Dec1_Hash(u32 prev, algo::U32Dec1 rhs) {
18863 prev = u32_Hash(prev, rhs.value);
18864 return prev;
18865}
18866
18867// --- algo.U32Dec1..Init
18868// Set all fields to initial values.
18869inline void algo::U32Dec1_Init(algo::U32Dec1& parent) {
18870 parent.value = u32(0);
18871}
18872inline algo::U32Dec2::U32Dec2(u32 in_value)
18873 : value(in_value)
18874{
18875}
18876inline algo::U32Dec2::U32Dec2() {
18877 algo::U32Dec2_Init(*this);
18878}
18879
18880
18881// --- algo.U32Dec2.value.qSetDouble
18882// Set value of field value.
18883// The value is rounded to the nearest integer.
18884// This ensures that truncation of a near-integer value does not occur.
18885// Example: 1.3 cannot be represented exactly as a double, the actual
18886// stored value will be 1.29999999. when we apply C truncation,
18887// we want to end up with 1.3, not 1.2.
18888inline void algo::value_qSetDouble(algo::U32Dec2& parent, double val) {
18889 double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
18890 // set underlying field.
18891 parent.value = intval;
18892}
18893
18894// --- algo.U32Dec2.value.GetDouble
18895inline double algo::value_GetDouble(const algo::U32Dec2& parent) {
18896 double ret;
18897 ret = parent.value / double(100);
18898 return ret;
18899}
18900
18901// --- algo.U32Dec2.value.GetInt
18902// Return integer portion (divide number by 100)
18903inline u32 algo::value_GetInt(const algo::U32Dec2& parent) {
18904 u32 ret;
18905 ret = parent.value / 100;
18906 return ret;
18907}
18908
18909// --- algo.U32Dec2.value.GetScale
18910// Return constant 100
18911inline u32 algo::U32Dec2_GetScale() {
18912 return 100;
18913}
18914
18915// --- algo.U32Dec2.value.Cast
18916inline algo::U32Dec2::operator u32 () const {
18917 return u32((*this).value);
18918}
18919
18920// --- algo.U32Dec2..Hash
18921inline u32 algo::U32Dec2_Hash(u32 prev, algo::U32Dec2 rhs) {
18922 prev = u32_Hash(prev, rhs.value);
18923 return prev;
18924}
18925
18926// --- algo.U32Dec2..Init
18927// Set all fields to initial values.
18928inline void algo::U32Dec2_Init(algo::U32Dec2& parent) {
18929 parent.value = u32(0);
18930}
18931inline algo::U32Dec3::U32Dec3(u32 in_value)
18932 : value(in_value)
18933{
18934}
18935inline algo::U32Dec3::U32Dec3() {
18936 algo::U32Dec3_Init(*this);
18937}
18938
18939
18940// --- algo.U32Dec3.value.qSetDouble
18941// Set value of field value.
18942// The value is rounded to the nearest integer.
18943// This ensures that truncation of a near-integer value does not occur.
18944// Example: 1.3 cannot be represented exactly as a double, the actual
18945// stored value will be 1.29999999. when we apply C truncation,
18946// we want to end up with 1.3, not 1.2.
18947inline void algo::value_qSetDouble(algo::U32Dec3& parent, double val) {
18948 double intval = val * 1000 + (val > 0 ? 0.5 : -0.5);
18949 // set underlying field.
18950 parent.value = intval;
18951}
18952
18953// --- algo.U32Dec3.value.GetDouble
18954inline double algo::value_GetDouble(const algo::U32Dec3& parent) {
18955 double ret;
18956 ret = parent.value / double(1000);
18957 return ret;
18958}
18959
18960// --- algo.U32Dec3.value.GetInt
18961// Return integer portion (divide number by 1000)
18962inline u32 algo::value_GetInt(const algo::U32Dec3& parent) {
18963 u32 ret;
18964 ret = parent.value / 1000;
18965 return ret;
18966}
18967
18968// --- algo.U32Dec3.value.GetScale
18969// Return constant 1000
18970inline u32 algo::U32Dec3_GetScale() {
18971 return 1000;
18972}
18973
18974// --- algo.U32Dec3.value.Cast
18975inline algo::U32Dec3::operator u32 () const {
18976 return u32((*this).value);
18977}
18978
18979// --- algo.U32Dec3..Hash
18980inline u32 algo::U32Dec3_Hash(u32 prev, algo::U32Dec3 rhs) {
18981 prev = u32_Hash(prev, rhs.value);
18982 return prev;
18983}
18984
18985// --- algo.U32Dec3..Init
18986// Set all fields to initial values.
18987inline void algo::U32Dec3_Init(algo::U32Dec3& parent) {
18988 parent.value = u32(0);
18989}
18990inline algo::U32Dec4::U32Dec4(u32 in_value)
18991 : value(in_value)
18992{
18993}
18994inline algo::U32Dec4::U32Dec4() {
18995 algo::U32Dec4_Init(*this);
18996}
18997
18998
18999// --- algo.U32Dec4.value.qSetDouble
19000// Set value of field value.
19001// The value is rounded to the nearest integer.
19002// This ensures that truncation of a near-integer value does not occur.
19003// Example: 1.3 cannot be represented exactly as a double, the actual
19004// stored value will be 1.29999999. when we apply C truncation,
19005// we want to end up with 1.3, not 1.2.
19006inline void algo::value_qSetDouble(algo::U32Dec4& parent, double val) {
19007 double intval = val * 10000 + (val > 0 ? 0.5 : -0.5);
19008 // set underlying field.
19009 parent.value = intval;
19010}
19011
19012// --- algo.U32Dec4.value.GetDouble
19013inline double algo::value_GetDouble(const algo::U32Dec4& parent) {
19014 double ret;
19015 ret = parent.value / double(10000);
19016 return ret;
19017}
19018
19019// --- algo.U32Dec4.value.GetInt
19020// Return integer portion (divide number by 10000)
19021inline u32 algo::value_GetInt(const algo::U32Dec4& parent) {
19022 u32 ret;
19023 ret = parent.value / 10000;
19024 return ret;
19025}
19026
19027// --- algo.U32Dec4.value.GetScale
19028// Return constant 10000
19029inline u32 algo::U32Dec4_GetScale() {
19030 return 10000;
19031}
19032
19033// --- algo.U32Dec4.value.Cast
19034inline algo::U32Dec4::operator u32 () const {
19035 return u32((*this).value);
19036}
19037
19038// --- algo.U32Dec4..Hash
19039inline u32 algo::U32Dec4_Hash(u32 prev, algo::U32Dec4 rhs) {
19040 prev = u32_Hash(prev, rhs.value);
19041 return prev;
19042}
19043
19044// --- algo.U32Dec4..Init
19045// Set all fields to initial values.
19046inline void algo::U32Dec4_Init(algo::U32Dec4& parent) {
19047 parent.value = u32(0);
19048}
19049inline algo::U32Dec5::U32Dec5(u32 in_value)
19050 : value(in_value)
19051{
19052}
19053inline algo::U32Dec5::U32Dec5() {
19054 algo::U32Dec5_Init(*this);
19055}
19056
19057
19058// --- algo.U32Dec5.value.qSetDouble
19059// Set value of field value.
19060// The value is rounded to the nearest integer.
19061// This ensures that truncation of a near-integer value does not occur.
19062// Example: 1.3 cannot be represented exactly as a double, the actual
19063// stored value will be 1.29999999. when we apply C truncation,
19064// we want to end up with 1.3, not 1.2.
19065inline void algo::value_qSetDouble(algo::U32Dec5& parent, double val) {
19066 double intval = val * 100000 + (val > 0 ? 0.5 : -0.5);
19067 // set underlying field.
19068 parent.value = intval;
19069}
19070
19071// --- algo.U32Dec5.value.GetDouble
19072inline double algo::value_GetDouble(const algo::U32Dec5& parent) {
19073 double ret;
19074 ret = parent.value / double(100000);
19075 return ret;
19076}
19077
19078// --- algo.U32Dec5.value.GetInt
19079// Return integer portion (divide number by 100000)
19080inline u32 algo::value_GetInt(const algo::U32Dec5& parent) {
19081 u32 ret;
19082 ret = parent.value / 100000;
19083 return ret;
19084}
19085
19086// --- algo.U32Dec5.value.GetScale
19087// Return constant 100000
19088inline u32 algo::U32Dec5_GetScale() {
19089 return 100000;
19090}
19091
19092// --- algo.U32Dec5.value.Cast
19093inline algo::U32Dec5::operator u32 () const {
19094 return u32((*this).value);
19095}
19096
19097// --- algo.U32Dec5..Hash
19098inline u32 algo::U32Dec5_Hash(u32 prev, algo::U32Dec5 rhs) {
19099 prev = u32_Hash(prev, rhs.value);
19100 return prev;
19101}
19102
19103// --- algo.U32Dec5..Init
19104// Set all fields to initial values.
19105inline void algo::U32Dec5_Init(algo::U32Dec5& parent) {
19106 parent.value = u32(0);
19107}
19108inline algo::U64Ary::U64Ary() {
19109 algo::U64Ary_Init(*this);
19110}
19111
19112inline algo::U64Ary::~U64Ary() {
19113 algo::U64Ary_Uninit(*this);
19114}
19115
19116
19117// --- algo.U64Ary.ary.EmptyQ
19118// Return true if index is empty
19119inline bool algo::ary_EmptyQ(algo::U64Ary& parent) {
19120 return parent.ary_n == 0;
19121}
19122
19123// --- algo.U64Ary.ary.Find
19124// Look up row by row id. Return NULL if out of range
19125inline u64* algo::ary_Find(algo::U64Ary& parent, u64 t) {
19126 u64 idx = t;
19127 u64 lim = parent.ary_n;
19128 if (idx >= lim) return NULL;
19129 return parent.ary_elems + idx;
19130}
19131
19132// --- algo.U64Ary.ary.Getary
19133// Return array pointer by value
19134inline algo::aryptr<u64> algo::ary_Getary(const algo::U64Ary& parent) {
19135 return algo::aryptr<u64>(parent.ary_elems, parent.ary_n);
19136}
19137
19138// --- algo.U64Ary.ary.Last
19139// Return pointer to last element of array, or NULL if array is empty
19140inline u64* algo::ary_Last(algo::U64Ary& parent) {
19141 return ary_Find(parent, u64(parent.ary_n-1));
19142}
19143
19144// --- algo.U64Ary.ary.Max
19145// Return max. number of items in the array
19146inline i32 algo::ary_Max(algo::U64Ary& parent) {
19147 (void)parent;
19148 return parent.ary_max;
19149}
19150
19151// --- algo.U64Ary.ary.N
19152// Return number of items in the array
19153inline i32 algo::ary_N(const algo::U64Ary& parent) {
19154 return parent.ary_n;
19155}
19156
19157// --- algo.U64Ary.ary.RemoveAll
19158inline void algo::ary_RemoveAll(algo::U64Ary& parent) {
19159 parent.ary_n = 0;
19160}
19161
19162// --- algo.U64Ary.ary.Reserve
19163// Make sure N *more* elements will fit in array. Process dies if out of memory
19164inline void algo::ary_Reserve(algo::U64Ary& parent, int n) {
19165 u32 new_n = parent.ary_n + n;
19166 if (UNLIKELY(new_n > parent.ary_max)) {
19167 ary_AbsReserve(parent, new_n);
19168 }
19169}
19170
19171// --- algo.U64Ary.ary.qFind
19172// 'quick' Access row by row id. No bounds checking.
19173inline u64& algo::ary_qFind(algo::U64Ary& parent, u64 t) {
19174 return parent.ary_elems[t];
19175}
19176
19177// --- algo.U64Ary.ary.qLast
19178// Return reference to last element of array. No bounds checking
19179inline u64& algo::ary_qLast(algo::U64Ary& parent) {
19180 return ary_qFind(parent, u64(parent.ary_n-1));
19181}
19182
19183// --- algo.U64Ary.ary.rowid_Get
19184// Return row id of specified element
19185inline u64 algo::ary_rowid_Get(algo::U64Ary& parent, u64 &elem) {
19186 u64 id = &elem - parent.ary_elems;
19187 return u64(id);
19188}
19189
19190// --- algo.U64Ary.ary_curs.Next
19191// proceed to next item
19192inline void algo::U64Ary_ary_curs_Next(U64Ary_ary_curs &curs) {
19193 curs.index++;
19194}
19195
19196// --- algo.U64Ary.ary_curs.Reset
19197inline void algo::U64Ary_ary_curs_Reset(U64Ary_ary_curs &curs, algo::U64Ary &parent) {
19198 curs.elems = parent.ary_elems;
19199 curs.n_elems = parent.ary_n;
19200 curs.index = 0;
19201}
19202
19203// --- algo.U64Ary.ary_curs.ValidQ
19204// cursor points to valid item
19205inline bool algo::U64Ary_ary_curs_ValidQ(U64Ary_ary_curs &curs) {
19206 return curs.index < curs.n_elems;
19207}
19208
19209// --- algo.U64Ary.ary_curs.Access
19210// item access
19211inline u64& algo::U64Ary_ary_curs_Access(U64Ary_ary_curs &curs) {
19212 return curs.elems[curs.index];
19213}
19214
19215// --- algo.U64Ary..Init
19216// Set all fields to initial values.
19217inline void algo::U64Ary_Init(algo::U64Ary& parent) {
19218 parent.ary_elems = 0; // (algo.U64Ary.ary)
19219 parent.ary_n = 0; // (algo.U64Ary.ary)
19220 parent.ary_max = 0; // (algo.U64Ary.ary)
19221}
19222inline algo::U64Dec10::U64Dec10(u64 in_value)
19223 : value(in_value)
19224{
19225}
19226inline algo::U64Dec10::U64Dec10() {
19227 algo::U64Dec10_Init(*this);
19228}
19229
19230
19231// --- algo.U64Dec10.value.qSetDouble
19232// Set value of field value.
19233// The value is rounded to the nearest integer.
19234// This ensures that truncation of a near-integer value does not occur.
19235// Example: 1.3 cannot be represented exactly as a double, the actual
19236// stored value will be 1.29999999. when we apply C truncation,
19237// we want to end up with 1.3, not 1.2.
19238inline void algo::value_qSetDouble(algo::U64Dec10& parent, double val) {
19239 double intval = val * 10000000000 + (val > 0 ? 0.5 : -0.5);
19240 // set underlying field.
19241 parent.value = intval;
19242}
19243
19244// --- algo.U64Dec10.value.GetDouble
19245inline double algo::value_GetDouble(const algo::U64Dec10& parent) {
19246 double ret;
19247 ret = parent.value / double(10000000000);
19248 return ret;
19249}
19250
19251// --- algo.U64Dec10.value.GetInt
19252// Return integer portion (divide number by 10000000000)
19253inline u64 algo::value_GetInt(const algo::U64Dec10& parent) {
19254 u64 ret;
19255 ret = parent.value / 10000000000;
19256 return ret;
19257}
19258
19259// --- algo.U64Dec10.value.GetScale
19260// Return constant 10000000000
19261inline u64 algo::U64Dec10_GetScale() {
19262 return 10000000000;
19263}
19264
19265// --- algo.U64Dec10.value.Cast
19266inline algo::U64Dec10::operator u64 () const {
19267 return u64((*this).value);
19268}
19269
19270// --- algo.U64Dec10..Hash
19271inline u32 algo::U64Dec10_Hash(u32 prev, algo::U64Dec10 rhs) {
19272 prev = u64_Hash(prev, rhs.value);
19273 return prev;
19274}
19275
19276// --- algo.U64Dec10..Init
19277// Set all fields to initial values.
19278inline void algo::U64Dec10_Init(algo::U64Dec10& parent) {
19279 parent.value = u64(0);
19280}
19281inline algo::U64Dec2::U64Dec2(u64 in_value)
19282 : value(in_value)
19283{
19284}
19285inline algo::U64Dec2::U64Dec2() {
19286 algo::U64Dec2_Init(*this);
19287}
19288
19289
19290// --- algo.U64Dec2.value.qSetDouble
19291// Set value of field value.
19292// The value is rounded to the nearest integer.
19293// This ensures that truncation of a near-integer value does not occur.
19294// Example: 1.3 cannot be represented exactly as a double, the actual
19295// stored value will be 1.29999999. when we apply C truncation,
19296// we want to end up with 1.3, not 1.2.
19297inline void algo::value_qSetDouble(algo::U64Dec2& parent, double val) {
19298 double intval = val * 100 + (val > 0 ? 0.5 : -0.5);
19299 // set underlying field.
19300 parent.value = intval;
19301}
19302
19303// --- algo.U64Dec2.value.GetDouble
19304inline double algo::value_GetDouble(const algo::U64Dec2& parent) {
19305 double ret;
19306 ret = parent.value / double(100);
19307 return ret;
19308}
19309
19310// --- algo.U64Dec2.value.GetInt
19311// Return integer portion (divide number by 100)
19312inline u64 algo::value_GetInt(const algo::U64Dec2& parent) {
19313 u64 ret;
19314 ret = parent.value / 100;
19315 return ret;
19316}
19317
19318// --- algo.U64Dec2.value.GetScale
19319// Return constant 100
19320inline u64 algo::U64Dec2_GetScale() {
19321 return 100;
19322}
19323
19324// --- algo.U64Dec2.value.Cast
19325inline algo::U64Dec2::operator u64 () const {
19326 return u64((*this).value);
19327}
19328
19329// --- algo.U64Dec2..Hash
19330inline u32 algo::U64Dec2_Hash(u32 prev, algo::U64Dec2 rhs) {
19331 prev = u64_Hash(prev, rhs.value);
19332 return prev;
19333}
19334
19335// --- algo.U64Dec2..Init
19336// Set all fields to initial values.
19337inline void algo::U64Dec2_Init(algo::U64Dec2& parent) {
19338 parent.value = u64(0);
19339}
19340inline algo::U64Dec4::U64Dec4(u64 in_value)
19341 : value(in_value)
19342{
19343}
19344inline algo::U64Dec4::U64Dec4() {
19345 algo::U64Dec4_Init(*this);
19346}
19347
19348
19349// --- algo.U64Dec4.value.qSetDouble
19350// Set value of field value.
19351// The value is rounded to the nearest integer.
19352// This ensures that truncation of a near-integer value does not occur.
19353// Example: 1.3 cannot be represented exactly as a double, the actual
19354// stored value will be 1.29999999. when we apply C truncation,
19355// we want to end up with 1.3, not 1.2.
19356inline void algo::value_qSetDouble(algo::U64Dec4& parent, double val) {
19357 double intval = val * 10000 + (val > 0 ? 0.5 : -0.5);
19358 // set underlying field.
19359 parent.value = intval;
19360}
19361
19362// --- algo.U64Dec4.value.GetDouble
19363inline double algo::value_GetDouble(const algo::U64Dec4& parent) {
19364 double ret;
19365 ret = parent.value / double(10000);
19366 return ret;
19367}
19368
19369// --- algo.U64Dec4.value.GetInt
19370// Return integer portion (divide number by 10000)
19371inline u64 algo::value_GetInt(const algo::U64Dec4& parent) {
19372 u64 ret;
19373 ret = parent.value / 10000;
19374 return ret;
19375}
19376
19377// --- algo.U64Dec4.value.GetScale
19378// Return constant 10000
19379inline u64 algo::U64Dec4_GetScale() {
19380 return 10000;
19381}
19382
19383// --- algo.U64Dec4.value.Cast
19384inline algo::U64Dec4::operator u64 () const {
19385 return u64((*this).value);
19386}
19387
19388// --- algo.U64Dec4..Hash
19389inline u32 algo::U64Dec4_Hash(u32 prev, algo::U64Dec4 rhs) {
19390 prev = u64_Hash(prev, rhs.value);
19391 return prev;
19392}
19393
19394// --- algo.U64Dec4..Init
19395// Set all fields to initial values.
19396inline void algo::U64Dec4_Init(algo::U64Dec4& parent) {
19397 parent.value = u64(0);
19398}
19399inline algo::U64Dec5::U64Dec5(u64 in_value)
19400 : value(in_value)
19401{
19402}
19403inline algo::U64Dec5::U64Dec5() {
19404 algo::U64Dec5_Init(*this);
19405}
19406
19407
19408// --- algo.U64Dec5.value.qSetDouble
19409// Set value of field value.
19410// The value is rounded to the nearest integer.
19411// This ensures that truncation of a near-integer value does not occur.
19412// Example: 1.3 cannot be represented exactly as a double, the actual
19413// stored value will be 1.29999999. when we apply C truncation,
19414// we want to end up with 1.3, not 1.2.
19415inline void algo::value_qSetDouble(algo::U64Dec5& parent, double val) {
19416 double intval = val * 100000 + (val > 0 ? 0.5 : -0.5);
19417 // set underlying field.
19418 parent.value = intval;
19419}
19420
19421// --- algo.U64Dec5.value.GetDouble
19422inline double algo::value_GetDouble(const algo::U64Dec5& parent) {
19423 double ret;
19424 ret = parent.value / double(100000);
19425 return ret;
19426}
19427
19428// --- algo.U64Dec5.value.GetInt
19429// Return integer portion (divide number by 100000)
19430inline u64 algo::value_GetInt(const algo::U64Dec5& parent) {
19431 u64 ret;
19432 ret = parent.value / 100000;
19433 return ret;
19434}
19435
19436// --- algo.U64Dec5.value.GetScale
19437// Return constant 100000
19438inline u64 algo::U64Dec5_GetScale() {
19439 return 100000;
19440}
19441
19442// --- algo.U64Dec5.value.Cast
19443inline algo::U64Dec5::operator u64 () const {
19444 return u64((*this).value);
19445}
19446
19447// --- algo.U64Dec5..Hash
19448inline u32 algo::U64Dec5_Hash(u32 prev, algo::U64Dec5 rhs) {
19449 prev = u64_Hash(prev, rhs.value);
19450 return prev;
19451}
19452
19453// --- algo.U64Dec5..Init
19454// Set all fields to initial values.
19455inline void algo::U64Dec5_Init(algo::U64Dec5& parent) {
19456 parent.value = u64(0);
19457}
19458inline algo::U64Dec6::U64Dec6(u64 in_value)
19459 : value(in_value)
19460{
19461}
19462inline algo::U64Dec6::U64Dec6() {
19463 algo::U64Dec6_Init(*this);
19464}
19465
19466
19467// --- algo.U64Dec6.value.qSetDouble
19468// Set value of field value.
19469// The value is rounded to the nearest integer.
19470// This ensures that truncation of a near-integer value does not occur.
19471// Example: 1.3 cannot be represented exactly as a double, the actual
19472// stored value will be 1.29999999. when we apply C truncation,
19473// we want to end up with 1.3, not 1.2.
19474inline void algo::value_qSetDouble(algo::U64Dec6& parent, double val) {
19475 double intval = val * 1000000 + (val > 0 ? 0.5 : -0.5);
19476 // set underlying field.
19477 parent.value = intval;
19478}
19479
19480// --- algo.U64Dec6.value.GetDouble
19481inline double algo::value_GetDouble(const algo::U64Dec6& parent) {
19482 double ret;
19483 ret = parent.value / double(1000000);
19484 return ret;
19485}
19486
19487// --- algo.U64Dec6.value.GetInt
19488// Return integer portion (divide number by 1000000)
19489inline u64 algo::value_GetInt(const algo::U64Dec6& parent) {
19490 u64 ret;
19491 ret = parent.value / 1000000;
19492 return ret;
19493}
19494
19495// --- algo.U64Dec6.value.GetScale
19496// Return constant 1000000
19497inline u64 algo::U64Dec6_GetScale() {
19498 return 1000000;
19499}
19500
19501// --- algo.U64Dec6.value.Cast
19502inline algo::U64Dec6::operator u64 () const {
19503 return u64((*this).value);
19504}
19505
19506// --- algo.U64Dec6..Hash
19507inline u32 algo::U64Dec6_Hash(u32 prev, algo::U64Dec6 rhs) {
19508 prev = u64_Hash(prev, rhs.value);
19509 return prev;
19510}
19511
19512// --- algo.U64Dec6..Init
19513// Set all fields to initial values.
19514inline void algo::U64Dec6_Init(algo::U64Dec6& parent) {
19515 parent.value = u64(0);
19516}
19517inline algo::U64Dec7::U64Dec7(u64 in_value)
19518 : value(in_value)
19519{
19520}
19521inline algo::U64Dec7::U64Dec7() {
19522 algo::U64Dec7_Init(*this);
19523}
19524
19525
19526// --- algo.U64Dec7.value.qSetDouble
19527// Set value of field value.
19528// The value is rounded to the nearest integer.
19529// This ensures that truncation of a near-integer value does not occur.
19530// Example: 1.3 cannot be represented exactly as a double, the actual
19531// stored value will be 1.29999999. when we apply C truncation,
19532// we want to end up with 1.3, not 1.2.
19533inline void algo::value_qSetDouble(algo::U64Dec7& parent, double val) {
19534 double intval = val * 10000000 + (val > 0 ? 0.5 : -0.5);
19535 // set underlying field.
19536 parent.value = intval;
19537}
19538
19539// --- algo.U64Dec7.value.GetDouble
19540inline double algo::value_GetDouble(const algo::U64Dec7& parent) {
19541 double ret;
19542 ret = parent.value / double(10000000);
19543 return ret;
19544}
19545
19546// --- algo.U64Dec7.value.GetInt
19547// Return integer portion (divide number by 10000000)
19548inline u64 algo::value_GetInt(const algo::U64Dec7& parent) {
19549 u64 ret;
19550 ret = parent.value / 10000000;
19551 return ret;
19552}
19553
19554// --- algo.U64Dec7.value.GetScale
19555// Return constant 10000000
19556inline u64 algo::U64Dec7_GetScale() {
19557 return 10000000;
19558}
19559
19560// --- algo.U64Dec7.value.Cast
19561inline algo::U64Dec7::operator u64 () const {
19562 return u64((*this).value);
19563}
19564
19565// --- algo.U64Dec7..Hash
19566inline u32 algo::U64Dec7_Hash(u32 prev, algo::U64Dec7 rhs) {
19567 prev = u64_Hash(prev, rhs.value);
19568 return prev;
19569}
19570
19571// --- algo.U64Dec7..Init
19572// Set all fields to initial values.
19573inline void algo::U64Dec7_Init(algo::U64Dec7& parent) {
19574 parent.value = u64(0);
19575}
19576inline algo::U64Dec8::U64Dec8(u64 in_value)
19577 : value(in_value)
19578{
19579}
19580inline algo::U64Dec8::U64Dec8() {
19581 algo::U64Dec8_Init(*this);
19582}
19583
19584
19585// --- algo.U64Dec8.value.qSetDouble
19586// Set value of field value.
19587// The value is rounded to the nearest integer.
19588// This ensures that truncation of a near-integer value does not occur.
19589// Example: 1.3 cannot be represented exactly as a double, the actual
19590// stored value will be 1.29999999. when we apply C truncation,
19591// we want to end up with 1.3, not 1.2.
19592inline void algo::value_qSetDouble(algo::U64Dec8& parent, double val) {
19593 double intval = val * 100000000 + (val > 0 ? 0.5 : -0.5);
19594 // set underlying field.
19595 parent.value = intval;
19596}
19597
19598// --- algo.U64Dec8.value.GetDouble
19599inline double algo::value_GetDouble(const algo::U64Dec8& parent) {
19600 double ret;
19601 ret = parent.value / double(100000000);
19602 return ret;
19603}
19604
19605// --- algo.U64Dec8.value.GetInt
19606// Return integer portion (divide number by 100000000)
19607inline u64 algo::value_GetInt(const algo::U64Dec8& parent) {
19608 u64 ret;
19609 ret = parent.value / 100000000;
19610 return ret;
19611}
19612
19613// --- algo.U64Dec8.value.GetScale
19614// Return constant 100000000
19615inline u64 algo::U64Dec8_GetScale() {
19616 return 100000000;
19617}
19618
19619// --- algo.U64Dec8..Hash
19620inline u32 algo::U64Dec8_Hash(u32 prev, algo::U64Dec8 rhs) {
19621 prev = u64_Hash(prev, rhs.value);
19622 return prev;
19623}
19624
19625// --- algo.U64Dec8..Init
19626// Set all fields to initial values.
19627inline void algo::U64Dec8_Init(algo::U64Dec8& parent) {
19628 parent.value = u64(0);
19629}
19630inline algo::U64Dec9::U64Dec9(u64 in_value)
19631 : value(in_value)
19632{
19633}
19634inline algo::U64Dec9::U64Dec9() {
19635 algo::U64Dec9_Init(*this);
19636}
19637
19638
19639// --- algo.U64Dec9.value.qSetDouble
19640// Set value of field value.
19641// The value is rounded to the nearest integer.
19642// This ensures that truncation of a near-integer value does not occur.
19643// Example: 1.3 cannot be represented exactly as a double, the actual
19644// stored value will be 1.29999999. when we apply C truncation,
19645// we want to end up with 1.3, not 1.2.
19646inline void algo::value_qSetDouble(algo::U64Dec9& parent, double val) {
19647 double intval = val * 1000000000 + (val > 0 ? 0.5 : -0.5);
19648 // set underlying field.
19649 parent.value = intval;
19650}
19651
19652// --- algo.U64Dec9.value.GetDouble
19653inline double algo::value_GetDouble(const algo::U64Dec9& parent) {
19654 double ret;
19655 ret = parent.value / double(1000000000);
19656 return ret;
19657}
19658
19659// --- algo.U64Dec9.value.GetInt
19660// Return integer portion (divide number by 1000000000)
19661inline u64 algo::value_GetInt(const algo::U64Dec9& parent) {
19662 u64 ret;
19663 ret = parent.value / 1000000000;
19664 return ret;
19665}
19666
19667// --- algo.U64Dec9.value.GetScale
19668// Return constant 1000000000
19669inline u64 algo::U64Dec9_GetScale() {
19670 return 1000000000;
19671}
19672
19673// --- algo.U64Dec9.value.Cast
19674inline algo::U64Dec9::operator u64 () const {
19675 return u64((*this).value);
19676}
19677
19678// --- algo.U64Dec9..Hash
19679inline u32 algo::U64Dec9_Hash(u32 prev, algo::U64Dec9 rhs) {
19680 prev = u64_Hash(prev, rhs.value);
19681 return prev;
19682}
19683
19684// --- algo.U64Dec9..Init
19685// Set all fields to initial values.
19686inline void algo::U64Dec9_Init(algo::U64Dec9& parent) {
19687 parent.value = u64(0);
19688}
19689inline algo::URL::URL(const algo::strptr& in_protocol
19690 ,const algo::strptr& in_username
19691 ,const algo::strptr& in_password
19692 ,const algo::strptr& in_server
19693 ,const algo::strptr& in_dir
19694 ,i32 in_port
19695 ,u32 in_source_addr_host
19696 ,const algo::strptr& in_host)
19697 : protocol(in_protocol)
19698 , username(in_username)
19699 , password(in_password)
19700 , server(in_server)
19701 , dir(in_dir)
19702 , port(in_port)
19703 , source_addr_host(in_source_addr_host)
19704 , host(in_host)
19705{
19706}
19707inline algo::URL::URL() {
19708 algo::URL_Init(*this);
19709}
19710
19711
19712// --- algo.URL..Init
19713// Set all fields to initial values.
19714inline void algo::URL_Init(algo::URL& parent) {
19715 parent.port = i32(-1);
19716 parent.source_addr_host = u32(0);
19717}
19718inline algo::UnDiff::UnDiff(i64 in_value)
19719 : value(in_value)
19720{
19721}
19722
19723inline bool algo::UnDiff::operator ==(const algo::UnDiff &rhs) const {
19724 return algo::UnDiff_Eq(const_cast<algo::UnDiff&>(*this),const_cast<algo::UnDiff&>(rhs));
19725}
19726
19727inline bool algo::UnDiff::operator !=(const algo::UnDiff &rhs) const {
19728 return !algo::UnDiff_Eq(const_cast<algo::UnDiff&>(*this),const_cast<algo::UnDiff&>(rhs));
19729}
19730
19731inline bool algo::UnDiff::operator <(const algo::UnDiff &rhs) const {
19732 return algo::UnDiff_Lt(const_cast<algo::UnDiff&>(*this),const_cast<algo::UnDiff&>(rhs));
19733}
19734
19735inline bool algo::UnDiff::operator >(const algo::UnDiff &rhs) const {
19736 return rhs < *this;
19737}
19738
19739inline bool algo::UnDiff::operator <=(const algo::UnDiff &rhs) const {
19740 return !(rhs < *this);
19741}
19742
19743inline bool algo::UnDiff::operator >=(const algo::UnDiff &rhs) const {
19744 return !(*this < rhs);
19745}
19746inline algo::UnDiff::UnDiff() {
19747 algo::UnDiff_Init(*this);
19748}
19749
19750
19751// --- algo.UnDiff..Hash
19752inline u32 algo::UnDiff_Hash(u32 prev, algo::UnDiff rhs) {
19753 prev = i64_Hash(prev, rhs.value);
19754 return prev;
19755}
19756
19757// --- algo.UnDiff..Lt
19758inline bool algo::UnDiff_Lt(algo::UnDiff lhs, algo::UnDiff rhs) {
19759 return i64_Lt(lhs.value, rhs.value);
19760}
19761
19762// --- algo.UnDiff..Cmp
19763inline i32 algo::UnDiff_Cmp(algo::UnDiff lhs, algo::UnDiff rhs) {
19764 i32 retval = 0;
19765 retval = i64_Cmp(lhs.value, rhs.value);
19766 return retval;
19767}
19768
19769// --- algo.UnDiff..Init
19770// Set all fields to initial values.
19771inline void algo::UnDiff_Init(algo::UnDiff& parent) {
19772 parent.value = i64(0);
19773}
19774
19775// --- algo.UnDiff..UpdateMax
19776// Attempt to make LHS bigger. Return true if it was changed
19777inline bool algo::UnDiff_UpdateMax(algo::UnDiff &lhs, algo::UnDiff rhs) {
19778 bool retval = lhs < rhs;
19779 if (retval) {
19780 lhs = rhs;
19781 }
19782 return retval;
19783}
19784
19785// --- algo.UnDiff..Min
19786// Return the lesser of two values
19787inline algo::UnDiff algo::UnDiff_Min(algo::UnDiff lhs, algo::UnDiff rhs) {
19788 return lhs < rhs ? lhs : rhs;
19789}
19790
19791// --- algo.UnDiff..UpdateMin
19792// Attempt to make LHS smaller. Return true if it was changed
19793inline bool algo::UnDiff_UpdateMin(algo::UnDiff &lhs, algo::UnDiff rhs) {
19794 bool retval = rhs < lhs;
19795 if (retval) {
19796 lhs = rhs;
19797 }
19798 return retval;
19799}
19800
19801// --- algo.UnDiff..Max
19802// Return the greater of two values
19803inline algo::UnDiff algo::UnDiff_Max(algo::UnDiff lhs, algo::UnDiff rhs) {
19804 return rhs < lhs ? lhs : rhs;
19805}
19806
19807// --- algo.UnDiff..Eq
19808inline bool algo::UnDiff_Eq(algo::UnDiff lhs, algo::UnDiff rhs) {
19809 bool retval = true;
19810 retval = i64_Eq(lhs.value, rhs.value);
19811 return retval;
19812}
19813
19814// --- algo.UnDiff..Update
19815// Set value. Return true if new value is different from old value.
19816inline bool algo::UnDiff_Update(algo::UnDiff &lhs, algo::UnDiff rhs) {
19817 bool ret = !UnDiff_Eq(lhs, rhs); // compare values
19818 if (ret) {
19819 lhs = rhs; // update
19820 }
19821 return ret;
19822}
19823inline algo::UnixDiff::UnixDiff(i64 in_value)
19824 : value(in_value)
19825{
19826}
19827
19828inline bool algo::UnixDiff::operator ==(const algo::UnixDiff &rhs) const {
19829 return algo::UnixDiff_Eq(const_cast<algo::UnixDiff&>(*this),const_cast<algo::UnixDiff&>(rhs));
19830}
19831
19832inline bool algo::UnixDiff::operator !=(const algo::UnixDiff &rhs) const {
19833 return !algo::UnixDiff_Eq(const_cast<algo::UnixDiff&>(*this),const_cast<algo::UnixDiff&>(rhs));
19834}
19835
19836inline bool algo::UnixDiff::operator <(const algo::UnixDiff &rhs) const {
19837 return algo::UnixDiff_Lt(const_cast<algo::UnixDiff&>(*this),const_cast<algo::UnixDiff&>(rhs));
19838}
19839
19840inline bool algo::UnixDiff::operator >(const algo::UnixDiff &rhs) const {
19841 return rhs < *this;
19842}
19843
19844inline bool algo::UnixDiff::operator <=(const algo::UnixDiff &rhs) const {
19845 return !(rhs < *this);
19846}
19847
19848inline bool algo::UnixDiff::operator >=(const algo::UnixDiff &rhs) const {
19849 return !(*this < rhs);
19850}
19851inline algo::UnixDiff::UnixDiff() {
19852 algo::UnixDiff_Init(*this);
19853}
19854
19855
19856// --- algo.UnixDiff..Hash
19857inline u32 algo::UnixDiff_Hash(u32 prev, algo::UnixDiff rhs) {
19858 prev = i64_Hash(prev, rhs.value);
19859 return prev;
19860}
19861
19862// --- algo.UnixDiff..Lt
19863inline bool algo::UnixDiff_Lt(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19864 return i64_Lt(lhs.value, rhs.value);
19865}
19866
19867// --- algo.UnixDiff..Cmp
19868inline i32 algo::UnixDiff_Cmp(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19869 i32 retval = 0;
19870 retval = i64_Cmp(lhs.value, rhs.value);
19871 return retval;
19872}
19873
19874// --- algo.UnixDiff..Init
19875// Set all fields to initial values.
19876inline void algo::UnixDiff_Init(algo::UnixDiff& parent) {
19877 parent.value = i64(0);
19878}
19879
19880// --- algo.UnixDiff..UpdateMax
19881// Attempt to make LHS bigger. Return true if it was changed
19882inline bool algo::UnixDiff_UpdateMax(algo::UnixDiff &lhs, algo::UnixDiff rhs) {
19883 bool retval = lhs < rhs;
19884 if (retval) {
19885 lhs = rhs;
19886 }
19887 return retval;
19888}
19889
19890// --- algo.UnixDiff..Min
19891// Return the lesser of two values
19892inline algo::UnixDiff algo::UnixDiff_Min(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19893 return lhs < rhs ? lhs : rhs;
19894}
19895
19896// --- algo.UnixDiff..UpdateMin
19897// Attempt to make LHS smaller. Return true if it was changed
19898inline bool algo::UnixDiff_UpdateMin(algo::UnixDiff &lhs, algo::UnixDiff rhs) {
19899 bool retval = rhs < lhs;
19900 if (retval) {
19901 lhs = rhs;
19902 }
19903 return retval;
19904}
19905
19906// --- algo.UnixDiff..Max
19907// Return the greater of two values
19908inline algo::UnixDiff algo::UnixDiff_Max(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19909 return rhs < lhs ? lhs : rhs;
19910}
19911
19912// --- algo.UnixDiff..Eq
19913inline bool algo::UnixDiff_Eq(algo::UnixDiff lhs, algo::UnixDiff rhs) {
19914 bool retval = true;
19915 retval = i64_Eq(lhs.value, rhs.value);
19916 return retval;
19917}
19918
19919// --- algo.UnixDiff..Update
19920// Set value. Return true if new value is different from old value.
19921inline bool algo::UnixDiff_Update(algo::UnixDiff &lhs, algo::UnixDiff rhs) {
19922 bool ret = !UnixDiff_Eq(lhs, rhs); // compare values
19923 if (ret) {
19924 lhs = rhs; // update
19925 }
19926 return ret;
19927}
19928inline algo::UnixTime::UnixTime(i64 in_value)
19929 : value(in_value)
19930{
19931}
19932
19933inline bool algo::UnixTime::operator ==(const algo::UnixTime &rhs) const {
19934 return algo::UnixTime_Eq(const_cast<algo::UnixTime&>(*this),const_cast<algo::UnixTime&>(rhs));
19935}
19936
19937inline bool algo::UnixTime::operator !=(const algo::UnixTime &rhs) const {
19938 return !algo::UnixTime_Eq(const_cast<algo::UnixTime&>(*this),const_cast<algo::UnixTime&>(rhs));
19939}
19940
19941inline bool algo::UnixTime::operator <(const algo::UnixTime &rhs) const {
19942 return algo::UnixTime_Lt(const_cast<algo::UnixTime&>(*this),const_cast<algo::UnixTime&>(rhs));
19943}
19944
19945inline bool algo::UnixTime::operator >(const algo::UnixTime &rhs) const {
19946 return rhs < *this;
19947}
19948
19949inline bool algo::UnixTime::operator <=(const algo::UnixTime &rhs) const {
19950 return !(rhs < *this);
19951}
19952
19953inline bool algo::UnixTime::operator >=(const algo::UnixTime &rhs) const {
19954 return !(*this < rhs);
19955}
19956inline algo::UnixTime::UnixTime() {
19957 algo::UnixTime_Init(*this);
19958}
19959
19960
19961// --- algo.UnixTime..Hash
19962inline u32 algo::UnixTime_Hash(u32 prev, algo::UnixTime rhs) {
19963 prev = i64_Hash(prev, rhs.value);
19964 return prev;
19965}
19966
19967// --- algo.UnixTime..Lt
19968inline bool algo::UnixTime_Lt(algo::UnixTime lhs, algo::UnixTime rhs) {
19969 return i64_Lt(lhs.value, rhs.value);
19970}
19971
19972// --- algo.UnixTime..Cmp
19973inline i32 algo::UnixTime_Cmp(algo::UnixTime lhs, algo::UnixTime rhs) {
19974 i32 retval = 0;
19975 retval = i64_Cmp(lhs.value, rhs.value);
19976 return retval;
19977}
19978
19979// --- algo.UnixTime..Init
19980// Set all fields to initial values.
19981inline void algo::UnixTime_Init(algo::UnixTime& parent) {
19982 parent.value = i64(0);
19983}
19984
19985// --- algo.UnixTime..UpdateMax
19986// Attempt to make LHS bigger. Return true if it was changed
19987inline bool algo::UnixTime_UpdateMax(algo::UnixTime &lhs, algo::UnixTime rhs) {
19988 bool retval = lhs < rhs;
19989 if (retval) {
19990 lhs = rhs;
19991 }
19992 return retval;
19993}
19994
19995// --- algo.UnixTime..Min
19996// Return the lesser of two values
19997inline algo::UnixTime algo::UnixTime_Min(algo::UnixTime lhs, algo::UnixTime rhs) {
19998 return lhs < rhs ? lhs : rhs;
19999}
20000
20001// --- algo.UnixTime..UpdateMin
20002// Attempt to make LHS smaller. Return true if it was changed
20003inline bool algo::UnixTime_UpdateMin(algo::UnixTime &lhs, algo::UnixTime rhs) {
20004 bool retval = rhs < lhs;
20005 if (retval) {
20006 lhs = rhs;
20007 }
20008 return retval;
20009}
20010
20011// --- algo.UnixTime..Max
20012// Return the greater of two values
20013inline algo::UnixTime algo::UnixTime_Max(algo::UnixTime lhs, algo::UnixTime rhs) {
20014 return rhs < lhs ? lhs : rhs;
20015}
20016
20017// --- algo.UnixTime..Eq
20018inline bool algo::UnixTime_Eq(algo::UnixTime lhs, algo::UnixTime rhs) {
20019 bool retval = true;
20020 retval = i64_Eq(lhs.value, rhs.value);
20021 return retval;
20022}
20023
20024// --- algo.UnixTime..Update
20025// Set value. Return true if new value is different from old value.
20026inline bool algo::UnixTime_Update(algo::UnixTime &lhs, algo::UnixTime rhs) {
20027 bool ret = !UnixTime_Eq(lhs, rhs); // compare values
20028 if (ret) {
20029 lhs = rhs; // update
20030 }
20031 return ret;
20032}
20033inline algo::WDiff::WDiff(i64 in_value)
20034 : value(in_value)
20035{
20036}
20037
20038inline bool algo::WDiff::operator ==(const algo::WDiff &rhs) const {
20039 return algo::WDiff_Eq(const_cast<algo::WDiff&>(*this),const_cast<algo::WDiff&>(rhs));
20040}
20041
20042inline bool algo::WDiff::operator !=(const algo::WDiff &rhs) const {
20043 return !algo::WDiff_Eq(const_cast<algo::WDiff&>(*this),const_cast<algo::WDiff&>(rhs));
20044}
20045
20046inline bool algo::WDiff::operator <(const algo::WDiff &rhs) const {
20047 return algo::WDiff_Lt(const_cast<algo::WDiff&>(*this),const_cast<algo::WDiff&>(rhs));
20048}
20049
20050inline bool algo::WDiff::operator >(const algo::WDiff &rhs) const {
20051 return rhs < *this;
20052}
20053
20054inline bool algo::WDiff::operator <=(const algo::WDiff &rhs) const {
20055 return !(rhs < *this);
20056}
20057
20058inline bool algo::WDiff::operator >=(const algo::WDiff &rhs) const {
20059 return !(*this < rhs);
20060}
20061inline algo::WDiff::WDiff() {
20062 algo::WDiff_Init(*this);
20063}
20064
20065
20066// --- algo.WDiff..Hash
20067inline u32 algo::WDiff_Hash(u32 prev, algo::WDiff rhs) {
20068 prev = i64_Hash(prev, rhs.value);
20069 return prev;
20070}
20071
20072// --- algo.WDiff..Lt
20073inline bool algo::WDiff_Lt(algo::WDiff lhs, algo::WDiff rhs) {
20074 return i64_Lt(lhs.value, rhs.value);
20075}
20076
20077// --- algo.WDiff..Cmp
20078inline i32 algo::WDiff_Cmp(algo::WDiff lhs, algo::WDiff rhs) {
20079 i32 retval = 0;
20080 retval = i64_Cmp(lhs.value, rhs.value);
20081 return retval;
20082}
20083
20084// --- algo.WDiff..Init
20085// Set all fields to initial values.
20086inline void algo::WDiff_Init(algo::WDiff& parent) {
20087 parent.value = i64(0);
20088}
20089
20090// --- algo.WDiff..UpdateMax
20091// Attempt to make LHS bigger. Return true if it was changed
20092inline bool algo::WDiff_UpdateMax(algo::WDiff &lhs, algo::WDiff rhs) {
20093 bool retval = lhs < rhs;
20094 if (retval) {
20095 lhs = rhs;
20096 }
20097 return retval;
20098}
20099
20100// --- algo.WDiff..Min
20101// Return the lesser of two values
20102inline algo::WDiff algo::WDiff_Min(algo::WDiff lhs, algo::WDiff rhs) {
20103 return lhs < rhs ? lhs : rhs;
20104}
20105
20106// --- algo.WDiff..UpdateMin
20107// Attempt to make LHS smaller. Return true if it was changed
20108inline bool algo::WDiff_UpdateMin(algo::WDiff &lhs, algo::WDiff rhs) {
20109 bool retval = rhs < lhs;
20110 if (retval) {
20111 lhs = rhs;
20112 }
20113 return retval;
20114}
20115
20116// --- algo.WDiff..Max
20117// Return the greater of two values
20118inline algo::WDiff algo::WDiff_Max(algo::WDiff lhs, algo::WDiff rhs) {
20119 return rhs < lhs ? lhs : rhs;
20120}
20121
20122// --- algo.WDiff..Eq
20123inline bool algo::WDiff_Eq(algo::WDiff lhs, algo::WDiff rhs) {
20124 bool retval = true;
20125 retval = i64_Eq(lhs.value, rhs.value);
20126 return retval;
20127}
20128
20129// --- algo.WDiff..Update
20130// Set value. Return true if new value is different from old value.
20131inline bool algo::WDiff_Update(algo::WDiff &lhs, algo::WDiff rhs) {
20132 bool ret = !WDiff_Eq(lhs, rhs); // compare values
20133 if (ret) {
20134 lhs = rhs; // update
20135 }
20136 return ret;
20137}
20138inline algo::WTime::WTime(i64 in_value)
20139 : value(in_value)
20140{
20141}
20142
20143inline bool algo::WTime::operator ==(const algo::WTime &rhs) const {
20144 return algo::WTime_Eq(const_cast<algo::WTime&>(*this),const_cast<algo::WTime&>(rhs));
20145}
20146
20147inline bool algo::WTime::operator !=(const algo::WTime &rhs) const {
20148 return !algo::WTime_Eq(const_cast<algo::WTime&>(*this),const_cast<algo::WTime&>(rhs));
20149}
20150
20151inline bool algo::WTime::operator <(const algo::WTime &rhs) const {
20152 return algo::WTime_Lt(const_cast<algo::WTime&>(*this),const_cast<algo::WTime&>(rhs));
20153}
20154
20155inline bool algo::WTime::operator >(const algo::WTime &rhs) const {
20156 return rhs < *this;
20157}
20158
20159inline bool algo::WTime::operator <=(const algo::WTime &rhs) const {
20160 return !(rhs < *this);
20161}
20162
20163inline bool algo::WTime::operator >=(const algo::WTime &rhs) const {
20164 return !(*this < rhs);
20165}
20166inline algo::WTime::WTime() {
20167 algo::WTime_Init(*this);
20168}
20169
20170
20171// --- algo.WTime..Hash
20172inline u32 algo::WTime_Hash(u32 prev, algo::WTime rhs) {
20173 prev = i64_Hash(prev, rhs.value);
20174 return prev;
20175}
20176
20177// --- algo.WTime..Lt
20178inline bool algo::WTime_Lt(algo::WTime lhs, algo::WTime rhs) {
20179 return i64_Lt(lhs.value, rhs.value);
20180}
20181
20182// --- algo.WTime..Cmp
20183inline i32 algo::WTime_Cmp(algo::WTime lhs, algo::WTime rhs) {
20184 i32 retval = 0;
20185 retval = i64_Cmp(lhs.value, rhs.value);
20186 return retval;
20187}
20188
20189// --- algo.WTime..Init
20190// Set all fields to initial values.
20191inline void algo::WTime_Init(algo::WTime& parent) {
20192 parent.value = i64(0);
20193}
20194
20195// --- algo.WTime..UpdateMax
20196// Attempt to make LHS bigger. Return true if it was changed
20197inline bool algo::WTime_UpdateMax(algo::WTime &lhs, algo::WTime rhs) {
20198 bool retval = lhs < rhs;
20199 if (retval) {
20200 lhs = rhs;
20201 }
20202 return retval;
20203}
20204
20205// --- algo.WTime..Min
20206// Return the lesser of two values
20207inline algo::WTime algo::WTime_Min(algo::WTime lhs, algo::WTime rhs) {
20208 return lhs < rhs ? lhs : rhs;
20209}
20210
20211// --- algo.WTime..UpdateMin
20212// Attempt to make LHS smaller. Return true if it was changed
20213inline bool algo::WTime_UpdateMin(algo::WTime &lhs, algo::WTime rhs) {
20214 bool retval = rhs < lhs;
20215 if (retval) {
20216 lhs = rhs;
20217 }
20218 return retval;
20219}
20220
20221// --- algo.WTime..Max
20222// Return the greater of two values
20223inline algo::WTime algo::WTime_Max(algo::WTime lhs, algo::WTime rhs) {
20224 return rhs < lhs ? lhs : rhs;
20225}
20226
20227// --- algo.WTime..Eq
20228inline bool algo::WTime_Eq(algo::WTime lhs, algo::WTime rhs) {
20229 bool retval = true;
20230 retval = i64_Eq(lhs.value, rhs.value);
20231 return retval;
20232}
20233
20234// --- algo.WTime..Update
20235// Set value. Return true if new value is different from old value.
20236inline bool algo::WTime_Update(algo::WTime &lhs, algo::WTime rhs) {
20237 bool ret = !WTime_Eq(lhs, rhs); // compare values
20238 if (ret) {
20239 lhs = rhs; // update
20240 }
20241 return ret;
20242}
20243inline algo::i32_Range::i32_Range(i32 in_beg
20244 ,i32 in_end)
20245 : beg(in_beg)
20246 , end(in_end)
20247{
20248}
20249
20250inline bool algo::i32_Range::operator ==(const algo::i32_Range &rhs) const {
20251 return algo::i32_Range_Eq(const_cast<algo::i32_Range&>(*this),const_cast<algo::i32_Range&>(rhs));
20252}
20253
20254inline bool algo::i32_Range::operator !=(const algo::i32_Range &rhs) const {
20255 return !algo::i32_Range_Eq(const_cast<algo::i32_Range&>(*this),const_cast<algo::i32_Range&>(rhs));
20256}
20257
20258inline bool algo::i32_Range::operator <(const algo::i32_Range &rhs) const {
20259 return algo::i32_Range_Lt(const_cast<algo::i32_Range&>(*this),const_cast<algo::i32_Range&>(rhs));
20260}
20261
20262inline bool algo::i32_Range::operator >(const algo::i32_Range &rhs) const {
20263 return rhs < *this;
20264}
20265
20266inline bool algo::i32_Range::operator <=(const algo::i32_Range &rhs) const {
20267 return !(rhs < *this);
20268}
20269
20270inline bool algo::i32_Range::operator >=(const algo::i32_Range &rhs) const {
20271 return !(*this < rhs);
20272}
20273inline algo::i32_Range::i32_Range() {
20274 algo::i32_Range_Init(*this);
20275}
20276
20277
20278// --- algo.i32_Range..Hash
20279inline u32 algo::i32_Range_Hash(u32 prev, const algo::i32_Range & rhs) {
20280 prev = i32_Hash(prev, rhs.beg);
20281 prev = i32_Hash(prev, rhs.end);
20282 return prev;
20283}
20284
20285// --- algo.i32_Range..Lt
20286inline bool algo::i32_Range_Lt(algo::i32_Range& lhs, algo::i32_Range& rhs) {
20287 return i32_Range_Cmp(lhs,rhs) < 0;
20288}
20289
20290// --- algo.i32_Range..Cmp
20291inline i32 algo::i32_Range_Cmp(algo::i32_Range& lhs, algo::i32_Range& rhs) {
20292 i32 retval = 0;
20293 retval = i32_Cmp(lhs.beg, rhs.beg);
20294 if (retval != 0) {
20295 return retval;
20296 }
20297 retval = i32_Cmp(lhs.end, rhs.end);
20298 return retval;
20299}
20300
20301// --- algo.i32_Range..Init
20302// Set all fields to initial values.
20303inline void algo::i32_Range_Init(algo::i32_Range& parent) {
20304 parent.beg = i32(0);
20305 parent.end = i32(0);
20306}
20307
20308// --- algo.i32_Range..Eq
20309inline bool algo::i32_Range_Eq(algo::i32_Range& lhs, algo::i32_Range& rhs) {
20310 bool retval = true;
20311 retval = i32_Eq(lhs.beg, rhs.beg);
20312 if (!retval) {
20313 return false;
20314 }
20315 retval = i32_Eq(lhs.end, rhs.end);
20316 return retval;
20317}
20318
20319// --- algo.i32_Range..Update
20320// Set value. Return true if new value is different from old value.
20321inline bool algo::i32_Range_Update(algo::i32_Range &lhs, algo::i32_Range& rhs) {
20322 bool ret = !i32_Range_Eq(lhs, rhs); // compare values
20323 if (ret) {
20324 lhs = rhs; // update
20325 }
20326 return ret;
20327}
20328
20329inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Attr &row) {// cfmt:algo.Attr.String
20330 algo::Attr_Print(const_cast<algo::Attr&>(row), str);
20331 return str;
20332}
20333
20334inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Bool &row) {// cfmt:algo.Bool.String
20335 algo::Bool_Print(const_cast<algo::Bool&>(row), str);
20336 return str;
20337}
20338
20339inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Comment &row) {// cfmt:algo.Comment.String
20340 algo::Comment_Print(const_cast<algo::Comment&>(row), str);
20341 return str;
20342}
20343
20344inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::CppExpr &row) {// cfmt:algo.CppExpr.String
20345 algo::CppExpr_Print(const_cast<algo::CppExpr&>(row), str);
20346 return str;
20347}
20348
20349inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::UnTime &row) {// cfmt:algo.UnTime.String
20350 algo::UnTime_Print(const_cast<algo::UnTime&>(row), str);
20351 return str;
20352}
20353
20354inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Decimal &row) {// cfmt:algo.Decimal.String
20355 algo::Decimal_Print(const_cast<algo::Decimal&>(row), str);
20356 return str;
20357}
20358
20359inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::DryrunQ &row) {// cfmt:algo.DryrunQ.String
20360 algo::DryrunQ_Print(const_cast<algo::DryrunQ&>(row), str);
20361 return str;
20362}
20363
20364inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::EchoQ &row) {// cfmt:algo.EchoQ.String
20365 algo::EchoQ_Print(const_cast<algo::EchoQ&>(row), str);
20366 return str;
20367}
20368
20369inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Errcode &row) {// cfmt:algo.Errcode.String
20370 algo::Errcode_Print(const_cast<algo::Errcode&>(row), str);
20371 return str;
20372}
20373
20374inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::FailokQ &row) {// cfmt:algo.FailokQ.String
20375 algo::FailokQ_Print(const_cast<algo::FailokQ&>(row), str);
20376 return str;
20377}
20378
20379inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::FieldId &row) {// cfmt:algo.FieldId.String
20380 algo::FieldId_Print(const_cast<algo::FieldId&>(row), str);
20381 return str;
20382}
20383
20384inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Fildes &row) {// cfmt:algo.Fildes.String
20385 algo::Fildes_Print(const_cast<algo::Fildes&>(row), str);
20386 return str;
20387}
20388
20389inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::FileFlags &row) {// cfmt:algo.FileFlags.String
20390 algo::FileFlags_Print(const_cast<algo::FileFlags&>(row), str);
20391 return str;
20392}
20393
20394inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec1 &row) {// cfmt:algo.I32Dec1.String
20395 algo::I32Dec1_Print(const_cast<algo::I32Dec1&>(row), str);
20396 return str;
20397}
20398
20399inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec2 &row) {// cfmt:algo.I32Dec2.String
20400 algo::I32Dec2_Print(const_cast<algo::I32Dec2&>(row), str);
20401 return str;
20402}
20403
20404inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec3 &row) {// cfmt:algo.I32Dec3.String
20405 algo::I32Dec3_Print(const_cast<algo::I32Dec3&>(row), str);
20406 return str;
20407}
20408
20409inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec4 &row) {// cfmt:algo.I32Dec4.String
20410 algo::I32Dec4_Print(const_cast<algo::I32Dec4&>(row), str);
20411 return str;
20412}
20413
20414inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I32Dec5 &row) {// cfmt:algo.I32Dec5.String
20415 algo::I32Dec5_Print(const_cast<algo::I32Dec5&>(row), str);
20416 return str;
20417}
20418
20419inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec1 &row) {// cfmt:algo.I64Dec1.String
20420 algo::I64Dec1_Print(const_cast<algo::I64Dec1&>(row), str);
20421 return str;
20422}
20423
20424inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec10 &row) {// cfmt:algo.I64Dec10.String
20425 algo::I64Dec10_Print(const_cast<algo::I64Dec10&>(row), str);
20426 return str;
20427}
20428
20429inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec2 &row) {// cfmt:algo.I64Dec2.String
20430 algo::I64Dec2_Print(const_cast<algo::I64Dec2&>(row), str);
20431 return str;
20432}
20433
20434inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec3 &row) {// cfmt:algo.I64Dec3.String
20435 algo::I64Dec3_Print(const_cast<algo::I64Dec3&>(row), str);
20436 return str;
20437}
20438
20439inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec4 &row) {// cfmt:algo.I64Dec4.String
20440 algo::I64Dec4_Print(const_cast<algo::I64Dec4&>(row), str);
20441 return str;
20442}
20443
20444inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec5 &row) {// cfmt:algo.I64Dec5.String
20445 algo::I64Dec5_Print(const_cast<algo::I64Dec5&>(row), str);
20446 return str;
20447}
20448
20449inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec6 &row) {// cfmt:algo.I64Dec6.String
20450 algo::I64Dec6_Print(const_cast<algo::I64Dec6&>(row), str);
20451 return str;
20452}
20453
20454inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec7 &row) {// cfmt:algo.I64Dec7.String
20455 algo::I64Dec7_Print(const_cast<algo::I64Dec7&>(row), str);
20456 return str;
20457}
20458
20459inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec8 &row) {// cfmt:algo.I64Dec8.String
20460 algo::I64Dec8_Print(const_cast<algo::I64Dec8&>(row), str);
20461 return str;
20462}
20463
20464inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::I64Dec9 &row) {// cfmt:algo.I64Dec9.String
20465 algo::I64Dec9_Print(const_cast<algo::I64Dec9&>(row), str);
20466 return str;
20467}
20468
20469inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::IOEvtFlags &row) {// cfmt:algo.IOEvtFlags.String
20470 algo::IOEvtFlags_Print(const_cast<algo::IOEvtFlags&>(row), str);
20471 return str;
20472}
20473
20474inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Imdb &row) {// cfmt:algo.Imdb.String
20475 algo::Imdb_Print(const_cast<algo::Imdb&>(row), str);
20476 return str;
20477}
20478
20479inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::ImrowPtr &row) {// cfmt:algo.ImrowPtr.String
20480 algo::ImrowPtr_Print(const_cast<algo::ImrowPtr&>(row), str);
20481 return str;
20482}
20483
20484inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Imtable &row) {// cfmt:algo.Imtable.String
20485 algo::Imtable_Print(const_cast<algo::Imtable&>(row), str);
20486 return str;
20487}
20488
20489inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Ipmask &row) {// cfmt:algo.Ipmask.String
20490 algo::Ipmask_Print(const_cast<algo::Ipmask&>(row), str);
20491 return str;
20492}
20493
20494inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Md5Digest &row) {// cfmt:algo.Md5Digest.String
20495 algo::Md5Digest_Print(const_cast<algo::Md5Digest&>(row), str);
20496 return str;
20497}
20498
20499inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Month &row) {// cfmt:algo.Month.String
20500 algo::Month_Print(const_cast<algo::Month&>(row), str);
20501 return str;
20502}
20503
20504inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::NumParseFlags &row) {// cfmt:algo.NumParseFlags.String
20505 algo::NumParseFlags_Print(const_cast<algo::NumParseFlags&>(row), str);
20506 return str;
20507}
20508
20509inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::SchedTime &row) {// cfmt:algo.SchedTime.String
20510 algo::SchedTime_Print(const_cast<algo::SchedTime&>(row), str);
20511 return str;
20512}
20513
20514inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::SeqType &row) {// cfmt:algo.SeqType.String
20515 algo::SeqType_Print(const_cast<algo::SeqType&>(row), str);
20516 return str;
20517}
20518
20519inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Sha1sig &row) {// cfmt:algo.Sha1sig.String
20520 algo::Sha1sig_Print(const_cast<algo::Sha1sig&>(row), str);
20521 return str;
20522}
20523
20524inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::StringAry &row) {// cfmt:algo.StringAry.String
20525 algo::StringAry_Print(const_cast<algo::StringAry&>(row), str);
20526 return str;
20527}
20528
20529inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::TermStyle &row) {// cfmt:algo.TermStyle.String
20530 algo::TermStyle_Print(const_cast<algo::TermStyle&>(row), str);
20531 return str;
20532}
20533
20534inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::TextJust &row) {// cfmt:algo.TextJust.String
20535 algo::TextJust_Print(const_cast<algo::TextJust&>(row), str);
20536 return str;
20537}
20538
20539inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::Tuple &row) {// cfmt:algo.Tuple.String
20540 algo::Tuple_Print(const_cast<algo::Tuple&>(row), str);
20541 return str;
20542}
20543
20544inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U16Dec2 &row) {// cfmt:algo.U16Dec2.String
20545 algo::U16Dec2_Print(const_cast<algo::U16Dec2&>(row), str);
20546 return str;
20547}
20548
20549inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec1 &row) {// cfmt:algo.U32Dec1.String
20550 algo::U32Dec1_Print(const_cast<algo::U32Dec1&>(row), str);
20551 return str;
20552}
20553
20554inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec2 &row) {// cfmt:algo.U32Dec2.String
20555 algo::U32Dec2_Print(const_cast<algo::U32Dec2&>(row), str);
20556 return str;
20557}
20558
20559inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec3 &row) {// cfmt:algo.U32Dec3.String
20560 algo::U32Dec3_Print(const_cast<algo::U32Dec3&>(row), str);
20561 return str;
20562}
20563
20564inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec4 &row) {// cfmt:algo.U32Dec4.String
20565 algo::U32Dec4_Print(const_cast<algo::U32Dec4&>(row), str);
20566 return str;
20567}
20568
20569inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U32Dec5 &row) {// cfmt:algo.U32Dec5.String
20570 algo::U32Dec5_Print(const_cast<algo::U32Dec5&>(row), str);
20571 return str;
20572}
20573
20574inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec10 &row) {// cfmt:algo.U64Dec10.String
20575 algo::U64Dec10_Print(const_cast<algo::U64Dec10&>(row), str);
20576 return str;
20577}
20578
20579inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec2 &row) {// cfmt:algo.U64Dec2.String
20580 algo::U64Dec2_Print(const_cast<algo::U64Dec2&>(row), str);
20581 return str;
20582}
20583
20584inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec4 &row) {// cfmt:algo.U64Dec4.String
20585 algo::U64Dec4_Print(const_cast<algo::U64Dec4&>(row), str);
20586 return str;
20587}
20588
20589inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec5 &row) {// cfmt:algo.U64Dec5.String
20590 algo::U64Dec5_Print(const_cast<algo::U64Dec5&>(row), str);
20591 return str;
20592}
20593
20594inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec6 &row) {// cfmt:algo.U64Dec6.String
20595 algo::U64Dec6_Print(const_cast<algo::U64Dec6&>(row), str);
20596 return str;
20597}
20598
20599inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec7 &row) {// cfmt:algo.U64Dec7.String
20600 algo::U64Dec7_Print(const_cast<algo::U64Dec7&>(row), str);
20601 return str;
20602}
20603
20604inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec8 &row) {// cfmt:algo.U64Dec8.String
20605 algo::U64Dec8_Print(const_cast<algo::U64Dec8&>(row), str);
20606 return str;
20607}
20608
20609inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::U64Dec9 &row) {// cfmt:algo.U64Dec9.String
20610 algo::U64Dec9_Print(const_cast<algo::U64Dec9&>(row), str);
20611 return str;
20612}
20613
20614inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::URL &row) {// cfmt:algo.URL.String
20615 algo::URL_Print(const_cast<algo::URL&>(row), str);
20616 return str;
20617}
20618
20619inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::UnDiff &row) {// cfmt:algo.UnDiff.String
20620 algo::UnDiff_Print(const_cast<algo::UnDiff&>(row), str);
20621 return str;
20622}
20623
20624inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::UnixDiff &row) {// cfmt:algo.UnixDiff.String
20625 algo::UnixDiff_Print(const_cast<algo::UnixDiff&>(row), str);
20626 return str;
20627}
20628
20629inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::UnixTime &row) {// cfmt:algo.UnixTime.String
20630 algo::UnixTime_Print(const_cast<algo::UnixTime&>(row), str);
20631 return str;
20632}
20633
20634inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::WDiff &row) {// cfmt:algo.WDiff.String
20635 algo::WDiff_Print(const_cast<algo::WDiff&>(row), str);
20636 return str;
20637}
20638
20639inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::WTime &row) {// cfmt:algo.WTime.String
20640 algo::WTime_Print(const_cast<algo::WTime&>(row), str);
20641 return str;
20642}
20643
20644inline algo::cstring &algo::operator <<(algo::cstring &str, const algo::i32_Range &row) {// cfmt:algo.i32_Range.String
20645 algo::i32_Range_Print(const_cast<algo::i32_Range&>(row), str);
20646 return str;
20647}